code review 4893043: url: new package

src/pkg/http/request_test.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package http_test
 
 import (
         "bytes"
         "fmt"
         . "http"
         "http/httptest"
         "io"
         "io/ioutil"
         "mime/multipart"
         "os"
         "reflect"
         "regexp"
         "strings"
         "testing"
+        "url"
 )
 
 type stringMultimap map[string][]string
 
 type parseTest struct {
         query string
         out   stringMultimap
 }
 
 var parseTests = []parseTest{
         {
                 query: "a=1&b=2",
                 out:   stringMultimap{"a": []string{"1"}, "b": []string{"2"}},
         },
         {
                 query: "a=1&a=2&a=banana",
                 out:   stringMultimap{"a": []string{"1", "2", "banana"}},
         },
         {
                 query: "ascii=%3Ckey%3A+0x90%3E",
                 out:   stringMultimap{"ascii": []string{"<key: 0x90>"}},
         },
 }
 
 func TestParseForm(t *testing.T) {
         for i, test := range parseTests {
-                form, err := ParseQuery(test.query)
+                form, err := url.ParseQuery(test.query)
                 if err != nil {
                         t.Errorf("test %d: Unexpected error: %v", i, err)
                         continue
                 }
                 if len(form) != len(test.out) {
                         t.Errorf("test %d: len(form) = %d, want %d", i, len(form), len(test.out))
                 }
                 for k, evs := range test.out {
                         vs, ok := form[k]
                         if !ok {
                                 t.Errorf("test %d: Missing key %q", i, k)
                                 continue
                         }
                         if len(vs) != len(evs) {
                                 t.Errorf("test %d: len(form[%q]) = %d, want %d", i, k, len(vs), len(evs))
                                 continue
                         }
                         for j, ev := range evs {
                                 if v := vs[j]; v != ev {
                                         t.Errorf("test %d: form[%q][%d] = %q, want %q", i, k, j, v, ev)
                                 }
                         }
                 }
         }
 }
 
 func TestQuery(t *testing.T) {
         req := &Request{Method: "GET"}
-        req.URL, _ = ParseURL("http://www.google.com/search?q=foo&q=bar")
+        req.URL, _ = url.Parse("http://www.google.com/search?q=foo&q=bar")
         if q := req.FormValue("q"); q != "foo" {
                 t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
         }
 }
 
 func TestPostQuery(t *testing.T) {
         req := &Request{Method: "POST"}
-        req.URL, _ = ParseURL("http://www.google.com/search?q=foo&q=bar&both=x")
+        req.URL, _ = url.Parse("http://www.google.com/search?q=foo&q=bar&both=x")
         req.Header = Header{
                 "Content-Type": {"application/x-www-form-urlencoded; boo!"},
         }
         req.Body = ioutil.NopCloser(strings.NewReader("z=post&both=y"))
         if q := req.FormValue("q"); q != "foo" {
                 t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
         }
         if z := req.FormValue("z"); z != "post" {
                 t.Errorf(`req.FormValue("z") = %q, want "post"`, z)
         }
@@ skipping 232 matching lines @@
 --MyBoundary
 Content-Disposition: form-data; name="texta"
 
 ` + textaValue + `
 --MyBoundary
 Content-Disposition: form-data; name="textb"
 
 ` + textbValue + `
 --MyBoundary--
 `