src/net/http/cgi/host_test.go - go - Git at Google

 // Copyright 2011 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.

 // Tests for package cgi

 package cgi

 import (
 	"bufio"
 	"bytes"
 	"fmt"
 	"io"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 )

 func newRequest(httpreq string) *http.Request {
 	buf := bufio.NewReader(strings.NewReader(httpreq))
 	req, err := http.ReadRequest(buf)
 	if err != nil {
 		panic("cgi: bogus http request in test: " + httpreq)
 	}
 	req.RemoteAddr = "1.2.3.4:1234"
 	return req
 }

 func runCgiTest(t *testing.T, h *Handler,
 	httpreq string,
 	expectedMap map[string]string, checks ...func(reqInfo map[string]string)) *httptest.ResponseRecorder {
 	rw := httptest.NewRecorder()
 	req := newRequest(httpreq)
 	h.ServeHTTP(rw, req)
 	runResponseChecks(t, rw, expectedMap, checks...)
 	return rw
 }

 func runResponseChecks(t *testing.T, rw *httptest.ResponseRecorder,
 	expectedMap map[string]string, checks ...func(reqInfo map[string]string)) {
 	// Make a map to hold the test map that the CGI returns.
 	m := make(map[string]string)
 	m["_body"] = rw.Body.String()
 	linesRead := 0
 readlines:
 	for {
 		line, err := rw.Body.ReadString('\n')
 		switch {
 		case err == io.EOF:
 			break readlines
 		case err != nil:
 			t.Fatalf("unexpected error reading from CGI: %v", err)
 		}
 		linesRead++
 		trimmedLine := strings.TrimRight(line, "\r\n")
 		k, v, ok := strings.Cut(trimmedLine, "=")
 		if !ok {
 			t.Fatalf("Unexpected response from invalid line number %v: %q; existing map=%v",
 				linesRead, line, m)
 		}
 		m[k] = v
 	}

 	for key, expected := range expectedMap {
 		got := m[key]
 		if key == "cwd" {
 			// For Windows. golang.org/issue/4645.
 			fi1, _ := os.Stat(got)
 			fi2, _ := os.Stat(expected)
 			if os.SameFile(fi1, fi2) {
 				got = expected
 			}
 		}
 		if got != expected {
 			t.Errorf("for key %q got %q; expected %q", key, got, expected)
 		}
 	}
 	for _, check := range checks {
 		check(m)
 	}
 }

 var cgiTested, cgiWorks bool

 func check(t *testing.T) {
 	if !cgiTested {
 		cgiTested = true
 		cgiWorks = exec.Command("./testdata/test.cgi").Run() == nil
 	}
 	if !cgiWorks {
 		// No Perl on Windows, needed by test.cgi
 		// TODO: make the child process be Go, not Perl.
 		t.Skip("Skipping test: test.cgi failed.")
 	}
 }

 func TestCGIBasicGet(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"test":                  "Hello CGI",
 		"param-a":               "b",
 		"param-foo":             "bar",
 		"env-GATEWAY_INTERFACE": "CGI/1.1",
 		"env-HTTP_HOST":         "example.com",
 		"env-PATH_INFO":         "",
 		"env-QUERY_STRING":      "foo=bar&a=b",
 		"env-REMOTE_ADDR":       "1.2.3.4",
 		"env-REMOTE_HOST":       "1.2.3.4",
 		"env-REMOTE_PORT":       "1234",
 		"env-REQUEST_METHOD":    "GET",
 		"env-REQUEST_URI":       "/test.cgi?foo=bar&a=b",
 		"env-SCRIPT_FILENAME":   "testdata/test.cgi",
 		"env-SCRIPT_NAME":       "/test.cgi",
 		"env-SERVER_NAME":       "example.com",
 		"env-SERVER_PORT":       "80",
 		"env-SERVER_SOFTWARE":   "go",
 	}
 	replay := runCgiTest(t, h, "GET /test.cgi?foo=bar&a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)

 	if expected, got := "text/html", replay.Header().Get("Content-Type"); got != expected {
 		t.Errorf("got a Content-Type of %q; expected %q", got, expected)
 	}
 	if expected, got := "X-Test-Value", replay.Header().Get("X-Test-Header"); got != expected {
 		t.Errorf("got a X-Test-Header of %q; expected %q", got, expected)
 	}
 }

 func TestCGIEnvIPv6(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"test":                  "Hello CGI",
 		"param-a":               "b",
 		"param-foo":             "bar",
 		"env-GATEWAY_INTERFACE": "CGI/1.1",
 		"env-HTTP_HOST":         "example.com",
 		"env-PATH_INFO":         "",
 		"env-QUERY_STRING":      "foo=bar&a=b",
 		"env-REMOTE_ADDR":       "2000::3000",
 		"env-REMOTE_HOST":       "2000::3000",
 		"env-REMOTE_PORT":       "12345",
 		"env-REQUEST_METHOD":    "GET",
 		"env-REQUEST_URI":       "/test.cgi?foo=bar&a=b",
 		"env-SCRIPT_FILENAME":   "testdata/test.cgi",
 		"env-SCRIPT_NAME":       "/test.cgi",
 		"env-SERVER_NAME":       "example.com",
 		"env-SERVER_PORT":       "80",
 		"env-SERVER_SOFTWARE":   "go",
 	}

 	rw := httptest.NewRecorder()
 	req := newRequest("GET /test.cgi?foo=bar&a=b HTTP/1.0\nHost: example.com\n\n")
 	req.RemoteAddr = "[2000::3000]:12345"
 	h.ServeHTTP(rw, req)
 	runResponseChecks(t, rw, expectedMap)
 }

 func TestCGIBasicGetAbsPath(t *testing.T) {
 	check(t)
 	pwd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("getwd error: %v", err)
 	}
 	h := &Handler{
 		Path: pwd + "/testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"env-REQUEST_URI":     "/test.cgi?foo=bar&a=b",
 		"env-SCRIPT_FILENAME": pwd + "/testdata/test.cgi",
 		"env-SCRIPT_NAME":     "/test.cgi",
 	}
 	runCgiTest(t, h, "GET /test.cgi?foo=bar&a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func TestPathInfo(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"param-a":             "b",
 		"env-PATH_INFO":       "/extrapath",
 		"env-QUERY_STRING":    "a=b",
 		"env-REQUEST_URI":     "/test.cgi/extrapath?a=b",
 		"env-SCRIPT_FILENAME": "testdata/test.cgi",
 		"env-SCRIPT_NAME":     "/test.cgi",
 	}
 	runCgiTest(t, h, "GET /test.cgi/extrapath?a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func TestPathInfoDirRoot(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/myscript/",
 	}
 	expectedMap := map[string]string{
 		"env-PATH_INFO":       "bar",
 		"env-QUERY_STRING":    "a=b",
 		"env-REQUEST_URI":     "/myscript/bar?a=b",
 		"env-SCRIPT_FILENAME": "testdata/test.cgi",
 		"env-SCRIPT_NAME":     "/myscript/",
 	}
 	runCgiTest(t, h, "GET /myscript/bar?a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func TestDupHeaders(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"env-REQUEST_URI":     "/myscript/bar?a=b",
 		"env-SCRIPT_FILENAME": "testdata/test.cgi",
 		"env-HTTP_COOKIE":     "nom=NOM; yum=YUM",
 		"env-HTTP_X_FOO":      "val1, val2",
 	}
 	runCgiTest(t, h, "GET /myscript/bar?a=b HTTP/1.0\n"+
 		"Cookie: nom=NOM\n"+
 		"Cookie: yum=YUM\n"+
 		"X-Foo: val1\n"+
 		"X-Foo: val2\n"+
 		"Host: example.com\n\n",
 		expectedMap)
 }

 // Issue 16405: CGI+http.Transport differing uses of HTTP_PROXY.
 // Verify we don't set the HTTP_PROXY environment variable.
 // Hope nobody was depending on it. It's not a known header, though.
 func TestDropProxyHeader(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"env-REQUEST_URI":     "/myscript/bar?a=b",
 		"env-SCRIPT_FILENAME": "testdata/test.cgi",
 		"env-HTTP_X_FOO":      "a",
 	}
 	runCgiTest(t, h, "GET /myscript/bar?a=b HTTP/1.0\n"+
 		"X-Foo: a\n"+
 		"Proxy: should_be_stripped\n"+
 		"Host: example.com\n\n",
 		expectedMap,
 		func(reqInfo map[string]string) {
 			if v, ok := reqInfo["env-HTTP_PROXY"]; ok {
 				t.Errorf("HTTP_PROXY = %q; should be absent", v)
 			}
 		})
 }

 func TestPathInfoNoRoot(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "",
 	}
 	expectedMap := map[string]string{
 		"env-PATH_INFO":       "/bar",
 		"env-QUERY_STRING":    "a=b",
 		"env-REQUEST_URI":     "/bar?a=b",
 		"env-SCRIPT_FILENAME": "testdata/test.cgi",
 		"env-SCRIPT_NAME":     "/",
 	}
 	runCgiTest(t, h, "GET /bar?a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func TestCGIBasicPost(t *testing.T) {
 	check(t)
 	postReq := `POST /test.cgi?a=b HTTP/1.0
 Host: example.com
 Content-Type: application/x-www-form-urlencoded
 Content-Length: 15

 postfoo=postbar`
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap := map[string]string{
 		"test":               "Hello CGI",
 		"param-postfoo":      "postbar",
 		"env-REQUEST_METHOD": "POST",
 		"env-CONTENT_LENGTH": "15",
 		"env-REQUEST_URI":    "/test.cgi?a=b",
 	}
 	runCgiTest(t, h, postReq, expectedMap)
 }

 func chunk(s string) string {
 	return fmt.Sprintf("%x\r\n%s\r\n", len(s), s)
 }

 // The CGI spec doesn't allow chunked requests.
 func TestCGIPostChunked(t *testing.T) {
 	check(t)
 	postReq := `POST /test.cgi?a=b HTTP/1.1
 Host: example.com
 Content-Type: application/x-www-form-urlencoded
 Transfer-Encoding: chunked

 ` + chunk("postfoo") + chunk("=") + chunk("postbar") + chunk("")

 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap := map[string]string{}
 	resp := runCgiTest(t, h, postReq, expectedMap)
 	if got, expected := resp.Code, http.StatusBadRequest; got != expected {
 		t.Fatalf("Expected %v response code from chunked request body; got %d",
 			expected, got)
 	}
 }

 func TestRedirect(t *testing.T) {
 	check(t)
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	rec := runCgiTest(t, h, "GET /test.cgi?loc=http://foo.com/ HTTP/1.0\nHost: example.com\n\n", nil)
 	if e, g := 302, rec.Code; e != g {
 		t.Errorf("expected status code %d; got %d", e, g)
 	}
 	if e, g := "http://foo.com/", rec.Header().Get("Location"); e != g {
 		t.Errorf("expected Location header of %q; got %q", e, g)
 	}
 }

 func TestInternalRedirect(t *testing.T) {
 	check(t)
 	baseHandler := http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
 		fmt.Fprintf(rw, "basepath=%s\n", req.URL.Path)
 		fmt.Fprintf(rw, "remoteaddr=%s\n", req.RemoteAddr)
 	})
 	h := &Handler{
 		Path:                "testdata/test.cgi",
 		Root:                "/test.cgi",
 		PathLocationHandler: baseHandler,
 	}
 	expectedMap := map[string]string{
 		"basepath":   "/foo",
 		"remoteaddr": "1.2.3.4:1234",
 	}
 	runCgiTest(t, h, "GET /test.cgi?loc=/foo HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 // TestCopyError tests that we kill the process if there's an error copying
 // its output. (for example, from the client having gone away)
 func TestCopyError(t *testing.T) {
 	check(t)
 	if runtime.GOOS == "windows" {
 		t.Skipf("skipping test on %q", runtime.GOOS)
 	}
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	ts := httptest.NewServer(h)
 	defer ts.Close()

 	conn, err := net.Dial("tcp", ts.Listener.Addr().String())
 	if err != nil {
 		t.Fatal(err)
 	}
 	req, _ := http.NewRequest("GET", "http://example.com/test.cgi?bigresponse=1", nil)
 	err = req.Write(conn)
 	if err != nil {
 		t.Fatalf("Write: %v", err)
 	}

 	res, err := http.ReadResponse(bufio.NewReader(conn), req)
 	if err != nil {
 		t.Fatalf("ReadResponse: %v", err)
 	}

 	pidstr := res.Header.Get("X-CGI-Pid")
 	if pidstr == "" {
 		t.Fatalf("expected an X-CGI-Pid header in response")
 	}
 	pid, err := strconv.Atoi(pidstr)
 	if err != nil {
 		t.Fatalf("invalid X-CGI-Pid value")
 	}

 	var buf [5000]byte
 	n, err := io.ReadFull(res.Body, buf[:])
 	if err != nil {
 		t.Fatalf("ReadFull: %d bytes, %v", n, err)
 	}

 	childRunning := func() bool {
 		return isProcessRunning(pid)
 	}

 	if !childRunning() {
 		t.Fatalf("pre-conn.Close, expected child to be running")
 	}
 	conn.Close()

 	tries := 0
 	for tries < 25 && childRunning() {
 		time.Sleep(50 * time.Millisecond * time.Duration(tries))
 		tries++
 	}
 	if childRunning() {
 		t.Fatalf("post-conn.Close, expected child to be gone")
 	}
 }

 func TestDirUnix(t *testing.T) {
 	check(t)
 	if runtime.GOOS == "windows" {
 		t.Skipf("skipping test on %q", runtime.GOOS)
 	}
 	cwd, _ := os.Getwd()
 	h := &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 		Dir:  cwd,
 	}
 	expectedMap := map[string]string{
 		"cwd": cwd,
 	}
 	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)

 	cwd, _ = os.Getwd()
 	cwd = filepath.Join(cwd, "testdata")
 	h = &Handler{
 		Path: "testdata/test.cgi",
 		Root: "/test.cgi",
 	}
 	expectedMap = map[string]string{
 		"cwd": cwd,
 	}
 	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func findPerl(t *testing.T) string {
 	t.Helper()
 	perl, err := exec.LookPath("perl")
 	if err != nil {
 		t.Skip("Skipping test: perl not found.")
 	}
 	perl, _ = filepath.Abs(perl)

 	cmd := exec.Command(perl, "-e", "print 123")
 	cmd.Env = []string{"PATH=/garbage"}
 	out, err := cmd.Output()
 	if err != nil || string(out) != "123" {
 		t.Skipf("Skipping test: %s is not functional", perl)
 	}
 	return perl
 }

 func TestDirWindows(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		t.Skip("Skipping windows specific test.")
 	}

 	cgifile, _ := filepath.Abs("testdata/test.cgi")

 	perl := findPerl(t)

 	cwd, _ := os.Getwd()
 	h := &Handler{
 		Path: perl,
 		Root: "/test.cgi",
 		Dir:  cwd,
 		Args: []string{cgifile},
 		Env:  []string{"SCRIPT_FILENAME=" + cgifile},
 	}
 	expectedMap := map[string]string{
 		"cwd": cwd,
 	}
 	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)

 	// If not specify Dir on windows, working directory should be
 	// base directory of perl.
 	cwd, _ = filepath.Split(perl)
 	if cwd != "" && cwd[len(cwd)-1] == filepath.Separator {
 		cwd = cwd[:len(cwd)-1]
 	}
 	h = &Handler{
 		Path: perl,
 		Root: "/test.cgi",
 		Args: []string{cgifile},
 		Env:  []string{"SCRIPT_FILENAME=" + cgifile},
 	}
 	expectedMap = map[string]string{
 		"cwd": cwd,
 	}
 	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func TestEnvOverride(t *testing.T) {
 	check(t)
 	cgifile, _ := filepath.Abs("testdata/test.cgi")

 	perl := findPerl(t)

 	cwd, _ := os.Getwd()
 	h := &Handler{
 		Path: perl,
 		Root: "/test.cgi",
 		Dir:  cwd,
 		Args: []string{cgifile},
 		Env: []string{
 			"SCRIPT_FILENAME=" + cgifile,
 			"REQUEST_URI=/foo/bar",
 			"PATH=/wibble"},
 	}
 	expectedMap := map[string]string{
 		"cwd":                 cwd,
 		"env-SCRIPT_FILENAME": cgifile,
 		"env-REQUEST_URI":     "/foo/bar",
 		"env-PATH":            "/wibble",
 	}
 	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }

 func TestHandlerStderr(t *testing.T) {
 	check(t)
 	var stderr bytes.Buffer
 	h := &Handler{
 		Path:   "testdata/test.cgi",
 		Root:   "/test.cgi",
 		Stderr: &stderr,
 	}

 	rw := httptest.NewRecorder()
 	req := newRequest("GET /test.cgi?writestderr=1 HTTP/1.0\nHost: example.com\n\n")
 	h.ServeHTTP(rw, req)
 	if got, want := stderr.String(), "Hello, stderr!\n"; got != want {
 		t.Errorf("Stderr = %q; want %q", got, want)
 	}
 }

 func TestRemoveLeadingDuplicates(t *testing.T) {
 	tests := []struct {
 		env  []string
 		want []string
 	}{
 		{
 			env:  []string{"a=b", "b=c", "a=b2"},
 			want: []string{"b=c", "a=b2"},
 		},
 		{
 			env:  []string{"a=b", "b=c", "d", "e=f"},
 			want: []string{"a=b", "b=c", "d", "e=f"},
 		},
 	}
 	for _, tt := range tests {
 		got := removeLeadingDuplicates(tt.env)
 		if !reflect.DeepEqual(got, tt.want) {
 			t.Errorf("removeLeadingDuplicates(%q) = %q; want %q", tt.env, got, tt.want)
 		}
 	}
 }
	// Copyright 2011 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.

	// Tests for package cgi

	package cgi

	import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"runtime"
	"strconv"
	"strings"
	"testing"
	"time"
	)

	func newRequest(httpreq string) *http.Request {
	buf := bufio.NewReader(strings.NewReader(httpreq))
	req, err := http.ReadRequest(buf)
	if err != nil {
	panic("cgi: bogus http request in test: " + httpreq)
	}
	req.RemoteAddr = "1.2.3.4:1234"
	return req
	}

	func runCgiTest(t testing.T, h Handler,
	httpreq string,
	expectedMap map[string]string, checks ...func(reqInfo map[string]string)) *httptest.ResponseRecorder {
	rw := httptest.NewRecorder()
	req := newRequest(httpreq)
	h.ServeHTTP(rw, req)
	runResponseChecks(t, rw, expectedMap, checks...)
	return rw
	}

	func runResponseChecks(t testing.T, rw httptest.ResponseRecorder,
	expectedMap map[string]string, checks ...func(reqInfo map[string]string)) {
	// Make a map to hold the test map that the CGI returns.
	m := make(map[string]string)
	m["_body"] = rw.Body.String()
	linesRead := 0
	readlines:
	for {
	line, err := rw.Body.ReadString('\n')
	switch {
	case err == io.EOF:
	break readlines
	case err != nil:
	t.Fatalf("unexpected error reading from CGI: %v", err)
	}
	linesRead++
	trimmedLine := strings.TrimRight(line, "\r\n")
	k, v, ok := strings.Cut(trimmedLine, "=")
	if !ok {
	t.Fatalf("Unexpected response from invalid line number %v: %q; existing map=%v",
	linesRead, line, m)
	}
	m[k] = v
	}

	for key, expected := range expectedMap {
	got := m[key]
	if key == "cwd" {
	// For Windows. golang.org/issue/4645.
	fi1, _ := os.Stat(got)
	fi2, _ := os.Stat(expected)
	if os.SameFile(fi1, fi2) {
	got = expected
	}
	}
	if got != expected {
	t.Errorf("for key %q got %q; expected %q", key, got, expected)
	}
	}
	for _, check := range checks {
	check(m)
	}
	}

	var cgiTested, cgiWorks bool

	func check(t *testing.T) {
	if !cgiTested {
	cgiTested = true
	cgiWorks = exec.Command("./testdata/test.cgi").Run() == nil
	}
	if !cgiWorks {
	// No Perl on Windows, needed by test.cgi
	// TODO: make the child process be Go, not Perl.
	t.Skip("Skipping test: test.cgi failed.")
	}
	}

	func TestCGIBasicGet(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap := map[string]string{
	"test": "Hello CGI",
	"param-a": "b",
	"param-foo": "bar",
	"env-GATEWAY_INTERFACE": "CGI/1.1",
	"env-HTTP_HOST": "example.com",
	"env-PATH_INFO": "",
	"env-QUERY_STRING": "foo=bar&a=b",
	"env-REMOTE_ADDR": "1.2.3.4",
	"env-REMOTE_HOST": "1.2.3.4",
	"env-REMOTE_PORT": "1234",
	"env-REQUEST_METHOD": "GET",
	"env-REQUEST_URI": "/test.cgi?foo=bar&a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-SCRIPT_NAME": "/test.cgi",
	"env-SERVER_NAME": "example.com",
	"env-SERVER_PORT": "80",
	"env-SERVER_SOFTWARE": "go",
	}
	replay := runCgiTest(t, h, "GET /test.cgi?foo=bar&a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)

	if expected, got := "text/html", replay.Header().Get("Content-Type"); got != expected {
	t.Errorf("got a Content-Type of %q; expected %q", got, expected)
	}
	if expected, got := "X-Test-Value", replay.Header().Get("X-Test-Header"); got != expected {
	t.Errorf("got a X-Test-Header of %q; expected %q", got, expected)
	}
	}

	func TestCGIEnvIPv6(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap := map[string]string{
	"test": "Hello CGI",
	"param-a": "b",
	"param-foo": "bar",
	"env-GATEWAY_INTERFACE": "CGI/1.1",
	"env-HTTP_HOST": "example.com",
	"env-PATH_INFO": "",
	"env-QUERY_STRING": "foo=bar&a=b",
	"env-REMOTE_ADDR": "2000::3000",
	"env-REMOTE_HOST": "2000::3000",
	"env-REMOTE_PORT": "12345",
	"env-REQUEST_METHOD": "GET",
	"env-REQUEST_URI": "/test.cgi?foo=bar&a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-SCRIPT_NAME": "/test.cgi",
	"env-SERVER_NAME": "example.com",
	"env-SERVER_PORT": "80",
	"env-SERVER_SOFTWARE": "go",
	}

	rw := httptest.NewRecorder()
	req := newRequest("GET /test.cgi?foo=bar&a=b HTTP/1.0\nHost: example.com\n\n")
	req.RemoteAddr = "[2000::3000]:12345"
	h.ServeHTTP(rw, req)
	runResponseChecks(t, rw, expectedMap)
	}

	func TestCGIBasicGetAbsPath(t *testing.T) {
	check(t)
	pwd, err := os.Getwd()
	if err != nil {
	t.Fatalf("getwd error: %v", err)
	}
	h := &Handler{
	Path: pwd + "/testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap := map[string]string{
	"env-REQUEST_URI": "/test.cgi?foo=bar&a=b",
	"env-SCRIPT_FILENAME": pwd + "/testdata/test.cgi",
	"env-SCRIPT_NAME": "/test.cgi",
	}
	runCgiTest(t, h, "GET /test.cgi?foo=bar&a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func TestPathInfo(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap := map[string]string{
	"param-a": "b",
	"env-PATH_INFO": "/extrapath",
	"env-QUERY_STRING": "a=b",
	"env-REQUEST_URI": "/test.cgi/extrapath?a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-SCRIPT_NAME": "/test.cgi",
	}
	runCgiTest(t, h, "GET /test.cgi/extrapath?a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func TestPathInfoDirRoot(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/myscript/",
	}
	expectedMap := map[string]string{
	"env-PATH_INFO": "bar",
	"env-QUERY_STRING": "a=b",
	"env-REQUEST_URI": "/myscript/bar?a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-SCRIPT_NAME": "/myscript/",
	}
	runCgiTest(t, h, "GET /myscript/bar?a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func TestDupHeaders(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	}
	expectedMap := map[string]string{
	"env-REQUEST_URI": "/myscript/bar?a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-HTTP_COOKIE": "nom=NOM; yum=YUM",
	"env-HTTP_X_FOO": "val1, val2",
	}
	runCgiTest(t, h, "GET /myscript/bar?a=b HTTP/1.0\n"+
	"Cookie: nom=NOM\n"+
	"Cookie: yum=YUM\n"+
	"X-Foo: val1\n"+
	"X-Foo: val2\n"+
	"Host: example.com\n\n",
	expectedMap)
	}

	// Issue 16405: CGI+http.Transport differing uses of HTTP_PROXY.
	// Verify we don't set the HTTP_PROXY environment variable.
	// Hope nobody was depending on it. It's not a known header, though.
	func TestDropProxyHeader(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	}
	expectedMap := map[string]string{
	"env-REQUEST_URI": "/myscript/bar?a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-HTTP_X_FOO": "a",
	}
	runCgiTest(t, h, "GET /myscript/bar?a=b HTTP/1.0\n"+
	"X-Foo: a\n"+
	"Proxy: should_be_stripped\n"+
	"Host: example.com\n\n",
	expectedMap,
	func(reqInfo map[string]string) {
	if v, ok := reqInfo["env-HTTP_PROXY"]; ok {
	t.Errorf("HTTP_PROXY = %q; should be absent", v)
	}
	})
	}

	func TestPathInfoNoRoot(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "",
	}
	expectedMap := map[string]string{
	"env-PATH_INFO": "/bar",
	"env-QUERY_STRING": "a=b",
	"env-REQUEST_URI": "/bar?a=b",
	"env-SCRIPT_FILENAME": "testdata/test.cgi",
	"env-SCRIPT_NAME": "/",
	}
	runCgiTest(t, h, "GET /bar?a=b HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func TestCGIBasicPost(t *testing.T) {
	check(t)
	postReq := `POST /test.cgi?a=b HTTP/1.0
	Host: example.com
	Content-Type: application/x-www-form-urlencoded
	Content-Length: 15

	postfoo=postbar`
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap := map[string]string{
	"test": "Hello CGI",
	"param-postfoo": "postbar",
	"env-REQUEST_METHOD": "POST",
	"env-CONTENT_LENGTH": "15",
	"env-REQUEST_URI": "/test.cgi?a=b",
	}
	runCgiTest(t, h, postReq, expectedMap)
	}

	func chunk(s string) string {
	return fmt.Sprintf("%x\r\n%s\r\n", len(s), s)
	}

	// The CGI spec doesn't allow chunked requests.
	func TestCGIPostChunked(t *testing.T) {
	check(t)
	postReq := `POST /test.cgi?a=b HTTP/1.1
	Host: example.com
	Content-Type: application/x-www-form-urlencoded
	Transfer-Encoding: chunked

	` + chunk("postfoo") + chunk("=") + chunk("postbar") + chunk("")

	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap := map[string]string{}
	resp := runCgiTest(t, h, postReq, expectedMap)
	if got, expected := resp.Code, http.StatusBadRequest; got != expected {
	t.Fatalf("Expected %v response code from chunked request body; got %d",
	expected, got)
	}
	}

	func TestRedirect(t *testing.T) {
	check(t)
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	rec := runCgiTest(t, h, "GET /test.cgi?loc=http://foo.com/ HTTP/1.0\nHost: example.com\n\n", nil)
	if e, g := 302, rec.Code; e != g {
	t.Errorf("expected status code %d; got %d", e, g)
	}
	if e, g := "http://foo.com/", rec.Header().Get("Location"); e != g {
	t.Errorf("expected Location header of %q; got %q", e, g)
	}
	}

	func TestInternalRedirect(t *testing.T) {
	check(t)
	baseHandler := http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
	fmt.Fprintf(rw, "basepath=%s\n", req.URL.Path)
	fmt.Fprintf(rw, "remoteaddr=%s\n", req.RemoteAddr)
	})
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	PathLocationHandler: baseHandler,
	}
	expectedMap := map[string]string{
	"basepath": "/foo",
	"remoteaddr": "1.2.3.4:1234",
	}
	runCgiTest(t, h, "GET /test.cgi?loc=/foo HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	// TestCopyError tests that we kill the process if there's an error copying
	// its output. (for example, from the client having gone away)
	func TestCopyError(t *testing.T) {
	check(t)
	if runtime.GOOS == "windows" {
	t.Skipf("skipping test on %q", runtime.GOOS)
	}
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	ts := httptest.NewServer(h)
	defer ts.Close()

	conn, err := net.Dial("tcp", ts.Listener.Addr().String())
	if err != nil {
	t.Fatal(err)
	}
	req, _ := http.NewRequest("GET", "http://example.com/test.cgi?bigresponse=1", nil)
	err = req.Write(conn)
	if err != nil {
	t.Fatalf("Write: %v", err)
	}

	res, err := http.ReadResponse(bufio.NewReader(conn), req)
	if err != nil {
	t.Fatalf("ReadResponse: %v", err)
	}

	pidstr := res.Header.Get("X-CGI-Pid")
	if pidstr == "" {
	t.Fatalf("expected an X-CGI-Pid header in response")
	}
	pid, err := strconv.Atoi(pidstr)
	if err != nil {
	t.Fatalf("invalid X-CGI-Pid value")
	}

	var buf [5000]byte
	n, err := io.ReadFull(res.Body, buf[:])
	if err != nil {
	t.Fatalf("ReadFull: %d bytes, %v", n, err)
	}

	childRunning := func() bool {
	return isProcessRunning(pid)
	}

	if !childRunning() {
	t.Fatalf("pre-conn.Close, expected child to be running")
	}
	conn.Close()

	tries := 0
	for tries < 25 && childRunning() {
	time.Sleep(50 * time.Millisecond * time.Duration(tries))
	tries++
	}
	if childRunning() {
	t.Fatalf("post-conn.Close, expected child to be gone")
	}
	}

	func TestDirUnix(t *testing.T) {
	check(t)
	if runtime.GOOS == "windows" {
	t.Skipf("skipping test on %q", runtime.GOOS)
	}
	cwd, _ := os.Getwd()
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	Dir: cwd,
	}
	expectedMap := map[string]string{
	"cwd": cwd,
	}
	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)

	cwd, _ = os.Getwd()
	cwd = filepath.Join(cwd, "testdata")
	h = &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	}
	expectedMap = map[string]string{
	"cwd": cwd,
	}
	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func findPerl(t *testing.T) string {
	t.Helper()
	perl, err := exec.LookPath("perl")
	if err != nil {
	t.Skip("Skipping test: perl not found.")
	}
	perl, _ = filepath.Abs(perl)

	cmd := exec.Command(perl, "-e", "print 123")
	cmd.Env = []string{"PATH=/garbage"}
	out, err := cmd.Output()
	if err != nil \|\| string(out) != "123" {
	t.Skipf("Skipping test: %s is not functional", perl)
	}
	return perl
	}

	func TestDirWindows(t *testing.T) {
	if runtime.GOOS != "windows" {
	t.Skip("Skipping windows specific test.")
	}

	cgifile, _ := filepath.Abs("testdata/test.cgi")

	perl := findPerl(t)

	cwd, _ := os.Getwd()
	h := &Handler{
	Path: perl,
	Root: "/test.cgi",
	Dir: cwd,
	Args: []string{cgifile},
	Env: []string{"SCRIPT_FILENAME=" + cgifile},
	}
	expectedMap := map[string]string{
	"cwd": cwd,
	}
	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)

	// If not specify Dir on windows, working directory should be
	// base directory of perl.
	cwd, _ = filepath.Split(perl)
	if cwd != "" && cwd[len(cwd)-1] == filepath.Separator {
	cwd = cwd[:len(cwd)-1]
	}
	h = &Handler{
	Path: perl,
	Root: "/test.cgi",
	Args: []string{cgifile},
	Env: []string{"SCRIPT_FILENAME=" + cgifile},
	}
	expectedMap = map[string]string{
	"cwd": cwd,
	}
	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func TestEnvOverride(t *testing.T) {
	check(t)
	cgifile, _ := filepath.Abs("testdata/test.cgi")

	perl := findPerl(t)

	cwd, _ := os.Getwd()
	h := &Handler{
	Path: perl,
	Root: "/test.cgi",
	Dir: cwd,
	Args: []string{cgifile},
	Env: []string{
	"SCRIPT_FILENAME=" + cgifile,
	"REQUEST_URI=/foo/bar",
	"PATH=/wibble"},
	}
	expectedMap := map[string]string{
	"cwd": cwd,
	"env-SCRIPT_FILENAME": cgifile,
	"env-REQUEST_URI": "/foo/bar",
	"env-PATH": "/wibble",
	}
	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
	}

	func TestHandlerStderr(t *testing.T) {
	check(t)
	var stderr bytes.Buffer
	h := &Handler{
	Path: "testdata/test.cgi",
	Root: "/test.cgi",
	Stderr: &stderr,
	}

	rw := httptest.NewRecorder()
	req := newRequest("GET /test.cgi?writestderr=1 HTTP/1.0\nHost: example.com\n\n")
	h.ServeHTTP(rw, req)
	if got, want := stderr.String(), "Hello, stderr!\n"; got != want {
	t.Errorf("Stderr = %q; want %q", got, want)
	}
	}

	func TestRemoveLeadingDuplicates(t *testing.T) {
	tests := []struct {
	env []string
	want []string
	}{
	{
	env: []string{"a=b", "b=c", "a=b2"},
	want: []string{"b=c", "a=b2"},
	},
	{
	env: []string{"a=b", "b=c", "d", "e=f"},
	want: []string{"a=b", "b=c", "d", "e=f"},
	},
	}
	for _, tt := range tests {
	got := removeLeadingDuplicates(tt.env)
	if !reflect.DeepEqual(got, tt.want) {
	t.Errorf("removeLeadingDuplicates(%q) = %q; want %q", tt.env, got, tt.want)
	}
	}
	}