1 files changed, 0 insertions, 403 deletions
diff --git a/gcc-4.8.1/libgo/go/net/http/request_test.go b/gcc-4.8.1/libgo/go/net/http/request_test.go
deleted file mode 100644
index bd757920b..000000000
--- a/gcc-4.8.1/libgo/go/net/http/request_test.go
+++ /dev/null
@@ -1,403 +0,0 @@
-// 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 (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"mime/multipart"
-	. "net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"reflect"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-func TestQuery(t *testing.T) {
-	req := &Request{Method: "GET"}
-	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, _ := NewRequest("POST", "http://www.google.com/search?q=foo&q=bar&both=x&prio=1&empty=not",
-		strings.NewReader("z=post&both=y&prio=2&empty="))
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
-
-	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)
-	}
-	if bq, found := req.PostForm["q"]; found {
-		t.Errorf(`req.PostForm["q"] = %q, want no entry in map`, bq)
-	}
-	if bz := req.PostFormValue("z"); bz != "post" {
-		t.Errorf(`req.PostFormValue("z") = %q, want "post"`, bz)
-	}
-	if qs := req.Form["q"]; !reflect.DeepEqual(qs, []string{"foo", "bar"}) {
-		t.Errorf(`req.Form["q"] = %q, want ["foo", "bar"]`, qs)
-	}
-	if both := req.Form["both"]; !reflect.DeepEqual(both, []string{"y", "x"}) {
-		t.Errorf(`req.Form["both"] = %q, want ["y", "x"]`, both)
-	}
-	if prio := req.FormValue("prio"); prio != "2" {
-		t.Errorf(`req.FormValue("prio") = %q, want "2" (from body)`, prio)
-	}
-	if empty := req.FormValue("empty"); empty != "" {
-		t.Errorf(`req.FormValue("empty") = %q, want "" (from body)`, empty)
-	}
-}
-
-type stringMap map[string][]string
-type parseContentTypeTest struct {
-	shouldError bool
-	contentType stringMap
-}
-
-var parseContentTypeTests = []parseContentTypeTest{
-	{false, stringMap{"Content-Type": {"text/plain"}}},
-	// Non-existent keys are not placed. The value nil is illegal.
-	{true, stringMap{}},
-	{true, stringMap{"Content-Type": {"text/plain; boundary="}}},
-	{false, stringMap{"Content-Type": {"application/unknown"}}},
-}
-
-func TestParseFormUnknownContentType(t *testing.T) {
-	for i, test := range parseContentTypeTests {
-		req := &Request{
-			Method: "POST",
-			Header: Header(test.contentType),
-			Body:   ioutil.NopCloser(bytes.NewBufferString("body")),
-		}
-		err := req.ParseForm()
-		switch {
-		case err == nil && test.shouldError:
-			t.Errorf("test %d should have returned error", i)
-		case err != nil && !test.shouldError:
-			t.Errorf("test %d should not have returned error, got %v", i, err)
-		}
-	}
-}
-
-func TestParseFormInitializeOnError(t *testing.T) {
-	nilBody, _ := NewRequest("POST", "http://www.google.com/search?q=foo", nil)
-	tests := []*Request{
-		nilBody,
-		{Method: "GET", URL: nil},
-	}
-	for i, req := range tests {
-		err := req.ParseForm()
-		if req.Form == nil {
-			t.Errorf("%d. Form not initialized, error %v", i, err)
-		}
-		if req.PostForm == nil {
-			t.Errorf("%d. PostForm not initialized, error %v", i, err)
-		}
-	}
-}
-
-func TestMultipartReader(t *testing.T) {
-	req := &Request{
-		Method: "POST",
-		Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
-		Body:   ioutil.NopCloser(new(bytes.Buffer)),
-	}
-	multipart, err := req.MultipartReader()
-	if multipart == nil {
-		t.Errorf("expected multipart; error: %v", err)
-	}
-
-	req.Header = Header{"Content-Type": {"text/plain"}}
-	multipart, err = req.MultipartReader()
-	if multipart != nil {
-		t.Errorf("unexpected multipart for text/plain")
-	}
-}
-
-func TestRedirect(t *testing.T) {
-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
-		switch r.URL.Path {
-		case "/":
-			w.Header().Set("Location", "/foo/")
-			w.WriteHeader(StatusSeeOther)
-		case "/foo/":
-			fmt.Fprintf(w, "foo")
-		default:
-			w.WriteHeader(StatusBadRequest)
-		}
-	}))
-	defer ts.Close()
-
-	var end = regexp.MustCompile("/foo/$")
-	r, err := Get(ts.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	r.Body.Close()
-	url := r.Request.URL.String()
-	if r.StatusCode != 200 || !end.MatchString(url) {
-		t.Fatalf("Get got status %d at %q, want 200 matching /foo/$", r.StatusCode, url)
-	}
-}
-
-func TestSetBasicAuth(t *testing.T) {
-	r, _ := NewRequest("GET", "http://example.com/", nil)
-	r.SetBasicAuth("Aladdin", "open sesame")
-	if g, e := r.Header.Get("Authorization"), "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="; g != e {
-		t.Errorf("got header %q, want %q", g, e)
-	}
-}
-
-func TestMultipartRequest(t *testing.T) {
-	// Test that we can read the values and files of a
-	// multipart request with FormValue and FormFile,
-	// and that ParseMultipartForm can be called multiple times.
-	req := newTestMultipartRequest(t)
-	if err := req.ParseMultipartForm(25); err != nil {
-		t.Fatal("ParseMultipartForm first call:", err)
-	}
-	defer req.MultipartForm.RemoveAll()
-	validateTestMultipartContents(t, req, false)
-	if err := req.ParseMultipartForm(25); err != nil {
-		t.Fatal("ParseMultipartForm second call:", err)
-	}
-	validateTestMultipartContents(t, req, false)
-}
-
-func TestMultipartRequestAuto(t *testing.T) {
-	// Test that FormValue and FormFile automatically invoke
-	// ParseMultipartForm and return the right values.
-	req := newTestMultipartRequest(t)
-	defer func() {
-		if req.MultipartForm != nil {
-			req.MultipartForm.RemoveAll()
-		}
-	}()
-	validateTestMultipartContents(t, req, true)
-}
-
-func TestEmptyMultipartRequest(t *testing.T) {
-	// Test that FormValue and FormFile automatically invoke
-	// ParseMultipartForm and return the right values.
-	req, err := NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Errorf("NewRequest err = %q", err)
-	}
-	testMissingFile(t, req)
-}
-
-func TestRequestMultipartCallOrder(t *testing.T) {
-	req := newTestMultipartRequest(t)
-	_, err := req.MultipartReader()
-	if err != nil {
-		t.Fatalf("MultipartReader: %v", err)
-	}
-	err = req.ParseMultipartForm(1024)
-	if err == nil {
-		t.Errorf("expected an error from ParseMultipartForm after call to MultipartReader")
-	}
-}
-
-var readRequestErrorTests = []struct {
-	in  string
-	err error
-}{
-	{"GET / HTTP/1.1\r\nheader:foo\r\n\r\n", nil},
-	{"GET / HTTP/1.1\r\nheader:foo\r\n", io.ErrUnexpectedEOF},
-	{"", io.EOF},
-}
-
-func TestReadRequestErrors(t *testing.T) {
-	for i, tt := range readRequestErrorTests {
-		_, err := ReadRequest(bufio.NewReader(strings.NewReader(tt.in)))
-		if err != tt.err {
-			t.Errorf("%d. got error = %v; want %v", i, err, tt.err)
-		}
-	}
-}
-
-func TestNewRequestHost(t *testing.T) {
-	req, err := NewRequest("GET", "http://localhost:1234/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if req.Host != "localhost:1234" {
-		t.Errorf("Host = %q; want localhost:1234", req.Host)
-	}
-}
-
-func TestNewRequestContentLength(t *testing.T) {
-	readByte := func(r io.Reader) io.Reader {
-		var b [1]byte
-		r.Read(b[:])
-		return r
-	}
-	tests := []struct {
-		r    io.Reader
-		want int64
-	}{
-		{bytes.NewReader([]byte("123")), 3},
-		{bytes.NewBuffer([]byte("1234")), 4},
-		{strings.NewReader("12345"), 5},
-		// Not detected:
-		{struct{ io.Reader }{strings.NewReader("xyz")}, 0},
-		{io.NewSectionReader(strings.NewReader("x"), 0, 6), 0},
-		{readByte(io.NewSectionReader(strings.NewReader("xy"), 0, 6)), 0},
-	}
-	for _, tt := range tests {
-		req, err := NewRequest("POST", "http://localhost/", tt.r)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if req.ContentLength != tt.want {
-			t.Errorf("ContentLength(%#T) = %d; want %d", tt.r, req.ContentLength, tt.want)
-		}
-	}
-}
-
-type logWrites struct {
-	t   *testing.T
-	dst *[]string
-}
-
-func (l logWrites) WriteByte(c byte) error {
-	l.t.Fatalf("unexpected WriteByte call")
-	return nil
-}
-
-func (l logWrites) Write(p []byte) (n int, err error) {
-	*l.dst = append(*l.dst, string(p))
-	return len(p), nil
-}
-
-func TestRequestWriteBufferedWriter(t *testing.T) {
-	got := []string{}
-	req, _ := NewRequest("GET", "http://foo.com/", nil)
-	req.Write(logWrites{t, &got})
-	want := []string{
-		"GET / HTTP/1.1\r\n",
-		"Host: foo.com\r\n",
-		"User-Agent: Go http package\r\n",
-		"\r\n",
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("Writes = %q\n  Want = %q", got, want)
-	}
-}
-
-func testMissingFile(t *testing.T, req *Request) {
-	f, fh, err := req.FormFile("missing")
-	if f != nil {
-		t.Errorf("FormFile file = %q, want nil", f)
-	}
-	if fh != nil {
-		t.Errorf("FormFile file header = %q, want nil", fh)
-	}
-	if err != ErrMissingFile {
-		t.Errorf("FormFile err = %q, want ErrMissingFile", err)
-	}
-}
-
-func newTestMultipartRequest(t *testing.T) *Request {
-	b := bytes.NewBufferString(strings.Replace(message, "\n", "\r\n", -1))
-	req, err := NewRequest("POST", "/", b)
-	if err != nil {
-		t.Fatal("NewRequest:", err)
-	}
-	ctype := fmt.Sprintf(`multipart/form-data; boundary="%s"`, boundary)
-	req.Header.Set("Content-type", ctype)
-	return req
-}
-
-func validateTestMultipartContents(t *testing.T, req *Request, allMem bool) {
-	if g, e := req.FormValue("texta"), textaValue; g != e {
-		t.Errorf("texta value = %q, want %q", g, e)
-	}
-	if g, e := req.FormValue("textb"), textbValue; g != e {
-		t.Errorf("textb value = %q, want %q", g, e)
-	}
-	if g := req.FormValue("missing"); g != "" {
-		t.Errorf("missing value = %q, want empty string", g)
-	}
-
-	assertMem := func(n string, fd multipart.File) {
-		if _, ok := fd.(*os.File); ok {
-			t.Error(n, " is *os.File, should not be")
-		}
-	}
-	fda := testMultipartFile(t, req, "filea", "filea.txt", fileaContents)
-	defer fda.Close()
-	assertMem("filea", fda)
-	fdb := testMultipartFile(t, req, "fileb", "fileb.txt", filebContents)
-	defer fdb.Close()
-	if allMem {
-		assertMem("fileb", fdb)
-	} else {
-		if _, ok := fdb.(*os.File); !ok {
-			t.Errorf("fileb has unexpected underlying type %T", fdb)
-		}
-	}
-
-	testMissingFile(t, req)
-}
-
-func testMultipartFile(t *testing.T, req *Request, key, expectFilename, expectContent string) multipart.File {
-	f, fh, err := req.FormFile(key)
-	if err != nil {
-		t.Fatalf("FormFile(%q): %q", key, err)
-	}
-	if fh.Filename != expectFilename {
-		t.Errorf("filename = %q, want %q", fh.Filename, expectFilename)
-	}
-	var b bytes.Buffer
-	_, err = io.Copy(&b, f)
-	if err != nil {
-		t.Fatal("copying contents:", err)
-	}
-	if g := b.String(); g != expectContent {
-		t.Errorf("contents = %q, want %q", g, expectContent)
-	}
-	return f
-}
-
-const (
-	fileaContents = "This is a test file."
-	filebContents = "Another test file."
-	textaValue    = "foo"
-	textbValue    = "bar"
-	boundary      = `MyBoundary`
-)
-
-const message = `
---MyBoundary
-Content-Disposition: form-data; name="filea"; filename="filea.txt"
-Content-Type: text/plain
-
-` + fileaContents + `
---MyBoundary
-Content-Disposition: form-data; name="fileb"; filename="fileb.txt"
-Content-Type: text/plain
-
-` + filebContents + `
---MyBoundary
-Content-Disposition: form-data; name="texta"
-
-` + textaValue + `
---MyBoundary
-Content-Disposition: form-data; name="textb"
-
-` + textbValue + `
---MyBoundary--
-`