How to use HandleHTTP method of got Package

1// Copyright 2014 Google Inc. All rights reserved.2// Use of this source code is governed by the Apache 2.03// license that can be found in the LICENSE file.4// +build !appengine5package internal6import (7	"bufio"8	"bytes"9	"fmt"10	"io"11	"io/ioutil"12	"net/http"13	"net/http/httptest"14	"net/url"15	"os"16	"os/exec"17	"strings"18	"sync/atomic"19	"testing"20	"time"21	"github.com/golang/protobuf/proto"22	netcontext "golang.org/x/net/context"23	basepb "google.golang.org/appengine/internal/base"24	remotepb "google.golang.org/appengine/internal/remote_api"25)26const testTicketHeader = "X-Magic-Ticket-Header"27func init() {28	ticketHeader = testTicketHeader29}30type fakeAPIHandler struct {31	hang chan int // used for RunSlowly RPC32	LogFlushes int32 // atomic33}34func (f *fakeAPIHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {35	writeResponse := func(res *remotepb.Response) {36		hresBody, err := proto.Marshal(res)37		if err != nil {38			http.Error(w, fmt.Sprintf("Failed encoding API response: %v", err), 500)39			return40		}41		w.Write(hresBody)42	}43	if r.URL.Path != "/rpc_http" {44		http.NotFound(w, r)45		return46	}47	hreqBody, err := ioutil.ReadAll(r.Body)48	if err != nil {49		http.Error(w, fmt.Sprintf("Bad body: %v", err), 500)50		return51	}52	apiReq := &remotepb.Request{}53	if err := proto.Unmarshal(hreqBody, apiReq); err != nil {54		http.Error(w, fmt.Sprintf("Bad encoded API request: %v", err), 500)55		return56	}57	if *apiReq.RequestId != "s3cr3t" && *apiReq.RequestId != DefaultTicket() {58		writeResponse(&remotepb.Response{59			RpcError: &remotepb.RpcError{60				Code:   proto.Int32(int32(remotepb.RpcError_SECURITY_VIOLATION)),61				Detail: proto.String("bad security ticket"),62			},63		})64		return65	}66	if got, want := r.Header.Get(dapperHeader), "trace-001"; got != want {67		writeResponse(&remotepb.Response{68			RpcError: &remotepb.RpcError{69				Code:   proto.Int32(int32(remotepb.RpcError_BAD_REQUEST)),70				Detail: proto.String(fmt.Sprintf("trace info = %q, want %q", got, want)),71			},72		})73		return74	}75	service, method := *apiReq.ServiceName, *apiReq.Method76	var resOut proto.Message77	if service == "actordb" && method == "LookupActor" {78		req := &basepb.StringProto{}79		res := &basepb.StringProto{}80		if err := proto.Unmarshal(apiReq.Request, req); err != nil {81			http.Error(w, fmt.Sprintf("Bad encoded request: %v", err), 500)82			return83		}84		if *req.Value == "Doctor Who" {85			res.Value = proto.String("David Tennant")86		}87		resOut = res88	}89	if service == "errors" {90		switch method {91		case "Non200":92			http.Error(w, "I'm a little teapot.", 418)93			return94		case "ShortResponse":95			w.Header().Set("Content-Length", "100")96			w.Write([]byte("way too short"))97			return98		case "OverQuota":99			writeResponse(&remotepb.Response{100				RpcError: &remotepb.RpcError{101					Code:   proto.Int32(int32(remotepb.RpcError_OVER_QUOTA)),102					Detail: proto.String("you are hogging the resources!"),103				},104			})105			return106		case "RunSlowly":107			// TestAPICallRPCFailure creates f.hang, but does not strobe it108			// until Call returns with remotepb.RpcError_CANCELLED.109			// This is here to force a happens-before relationship between110			// the httptest server handler and shutdown.111			<-f.hang112			resOut = &basepb.VoidProto{}113		}114	}115	if service == "logservice" && method == "Flush" {116		// Pretend log flushing is slow.117		time.Sleep(50 * time.Millisecond)118		atomic.AddInt32(&f.LogFlushes, 1)119		resOut = &basepb.VoidProto{}120	}121	encOut, err := proto.Marshal(resOut)122	if err != nil {123		http.Error(w, fmt.Sprintf("Failed encoding response: %v", err), 500)124		return125	}126	writeResponse(&remotepb.Response{127		Response: encOut,128	})129}130func setup() (f *fakeAPIHandler, c *context, cleanup func()) {131	f = &fakeAPIHandler{}132	srv := httptest.NewServer(f)133	u, err := url.Parse(srv.URL + apiPath)134	if err != nil {135		panic(fmt.Sprintf("url.Parse(%q): %v", srv.URL+apiPath, err))136	}137	return f, &context{138		req: &http.Request{139			Header: http.Header{140				ticketHeader: []string{"s3cr3t"},141				dapperHeader: []string{"trace-001"},142			},143		},144		apiURL: u,145	}, srv.Close146}147func TestAPICall(t *testing.T) {148	_, c, cleanup := setup()149	defer cleanup()150	req := &basepb.StringProto{151		Value: proto.String("Doctor Who"),152	}153	res := &basepb.StringProto{}154	err := Call(toContext(c), "actordb", "LookupActor", req, res)155	if err != nil {156		t.Fatalf("API call failed: %v", err)157	}158	if got, want := *res.Value, "David Tennant"; got != want {159		t.Errorf("Response is %q, want %q", got, want)160	}161}162func TestAPICallTicketUnavailable(t *testing.T) {163	resetEnv := SetTestEnv()164	defer resetEnv()165	_, c, cleanup := setup()166	defer cleanup()167	c.req.Header.Set(ticketHeader, "")168	req := &basepb.StringProto{169		Value: proto.String("Doctor Who"),170	}171	res := &basepb.StringProto{}172	err := Call(toContext(c), "actordb", "LookupActor", req, res)173	if err != nil {174		t.Fatalf("API call failed: %v", err)175	}176	if got, want := *res.Value, "David Tennant"; got != want {177		t.Errorf("Response is %q, want %q", got, want)178	}179}180func TestAPICallRPCFailure(t *testing.T) {181	f, c, cleanup := setup()182	defer cleanup()183	testCases := []struct {184		method string185		code   remotepb.RpcError_ErrorCode186	}{187		{"Non200", remotepb.RpcError_UNKNOWN},188		{"ShortResponse", remotepb.RpcError_UNKNOWN},189		{"OverQuota", remotepb.RpcError_OVER_QUOTA},190		{"RunSlowly", remotepb.RpcError_CANCELLED},191	}192	f.hang = make(chan int) // only for RunSlowly193	for _, tc := range testCases {194		ctx, _ := netcontext.WithTimeout(toContext(c), 100*time.Millisecond)195		err := Call(ctx, "errors", tc.method, &basepb.VoidProto{}, &basepb.VoidProto{})196		ce, ok := err.(*CallError)197		if !ok {198			t.Errorf("%s: API call error is %T (%v), want *CallError", tc.method, err, err)199			continue200		}201		if ce.Code != int32(tc.code) {202			t.Errorf("%s: ce.Code = %d, want %d", tc.method, ce.Code, tc.code)203		}204		if tc.method == "RunSlowly" {205			f.hang <- 1 // release the HTTP handler206		}207	}208}209func TestAPICallDialFailure(t *testing.T) {210	// See what happens if the API host is unresponsive.211	// This should time out quickly, not hang forever.212	_, c, cleanup := setup()213	defer cleanup()214	// Reset the URL to the production address so that dialing fails.215	c.apiURL = apiURL()216	start := time.Now()217	err := Call(toContext(c), "foo", "bar", &basepb.VoidProto{}, &basepb.VoidProto{})218	const max = 1 * time.Second219	if taken := time.Since(start); taken > max {220		t.Errorf("Dial hang took too long: %v > %v", taken, max)221	}222	if err == nil {223		t.Error("Call did not fail")224	}225}226func TestDelayedLogFlushing(t *testing.T) {227	f, c, cleanup := setup()228	defer cleanup()229	http.HandleFunc("/slow_log", func(w http.ResponseWriter, r *http.Request) {230		logC := WithContext(netcontext.Background(), r)231		fromContext(logC).apiURL = c.apiURL // Otherwise it will try to use the default URL.232		Logf(logC, 1, "It's a lovely day.")233		w.WriteHeader(200)234		time.Sleep(1200 * time.Millisecond)235		w.Write(make([]byte, 100<<10)) // write 100 KB to force HTTP flush236	})237	r := &http.Request{238		Method: "GET",239		URL: &url.URL{240			Scheme: "http",241			Path:   "/slow_log",242		},243		Header: c.req.Header,244		Body:   ioutil.NopCloser(bytes.NewReader(nil)),245	}246	w := httptest.NewRecorder()247	handled := make(chan struct{})248	go func() {249		defer close(handled)250		handleHTTP(w, r)251	}()252	// Check that the log flush eventually comes in.253	time.Sleep(1200 * time.Millisecond)254	if f := atomic.LoadInt32(&f.LogFlushes); f != 1 {255		t.Errorf("After 1.2s: f.LogFlushes = %d, want 1", f)256	}257	<-handled258	const hdr = "X-AppEngine-Log-Flush-Count"259	if got, want := w.HeaderMap.Get(hdr), "1"; got != want {260		t.Errorf("%s header = %q, want %q", hdr, got, want)261	}262	if got, want := atomic.LoadInt32(&f.LogFlushes), int32(2); got != want {263		t.Errorf("After HTTP response: f.LogFlushes = %d, want %d", got, want)264	}265}266func TestLogFlushing(t *testing.T) {267	f, c, cleanup := setup()268	defer cleanup()269	http.HandleFunc("/quick_log", func(w http.ResponseWriter, r *http.Request) {270		logC := WithContext(netcontext.Background(), r)271		fromContext(logC).apiURL = c.apiURL // Otherwise it will try to use the default URL.272		Logf(logC, 1, "It's a lovely day.")273		w.WriteHeader(200)274		w.Write(make([]byte, 100<<10)) // write 100 KB to force HTTP flush275	})276	r := &http.Request{277		Method: "GET",278		URL: &url.URL{279			Scheme: "http",280			Path:   "/quick_log",281		},282		Header: c.req.Header,283		Body:   ioutil.NopCloser(bytes.NewReader(nil)),284	}285	w := httptest.NewRecorder()286	handleHTTP(w, r)287	const hdr = "X-AppEngine-Log-Flush-Count"288	if got, want := w.HeaderMap.Get(hdr), "1"; got != want {289		t.Errorf("%s header = %q, want %q", hdr, got, want)290	}291	if got, want := atomic.LoadInt32(&f.LogFlushes), int32(1); got != want {292		t.Errorf("After HTTP response: f.LogFlushes = %d, want %d", got, want)293	}294}295func TestRemoteAddr(t *testing.T) {296	var addr string297	http.HandleFunc("/remote_addr", func(w http.ResponseWriter, r *http.Request) {298		addr = r.RemoteAddr299	})300	testCases := []struct {301		headers http.Header302		addr    string303	}{304		{http.Header{"X-Appengine-User-Ip": []string{"10.5.2.1"}}, "10.5.2.1:80"},305		{http.Header{"X-Appengine-Remote-Addr": []string{"1.2.3.4"}}, "1.2.3.4:80"},306		{http.Header{"X-Appengine-Remote-Addr": []string{"1.2.3.4:8080"}}, "1.2.3.4:8080"},307		{308			http.Header{"X-Appengine-Remote-Addr": []string{"2401:fa00:9:1:7646:a0ff:fe90:ca66"}},309			"[2401:fa00:9:1:7646:a0ff:fe90:ca66]:80",310		},311		{312			http.Header{"X-Appengine-Remote-Addr": []string{"[::1]:http"}},313			"[::1]:http",314		},315		{http.Header{}, "127.0.0.1:80"},316	}317	for _, tc := range testCases {318		r := &http.Request{319			Method: "GET",320			URL:    &url.URL{Scheme: "http", Path: "/remote_addr"},321			Header: tc.headers,322			Body:   ioutil.NopCloser(bytes.NewReader(nil)),323		}324		handleHTTP(httptest.NewRecorder(), r)325		if addr != tc.addr {326			t.Errorf("Header %v, got %q, want %q", tc.headers, addr, tc.addr)327		}328	}329}330func TestPanickingHandler(t *testing.T) {331	http.HandleFunc("/panic", func(http.ResponseWriter, *http.Request) {332		panic("whoops!")333	})334	r := &http.Request{335		Method: "GET",336		URL:    &url.URL{Scheme: "http", Path: "/panic"},337		Body:   ioutil.NopCloser(bytes.NewReader(nil)),338	}339	rec := httptest.NewRecorder()340	handleHTTP(rec, r)341	if rec.Code != 500 {342		t.Errorf("Panicking handler returned HTTP %d, want HTTP %d", rec.Code, 500)343	}344}345var raceDetector = false346func TestAPICallAllocations(t *testing.T) {347	if raceDetector {348		t.Skip("not running under race detector")349	}350	// Run the test API server in a subprocess so we aren't counting its allocations.351	u, cleanup := launchHelperProcess(t)352	defer cleanup()353	c := &context{354		req: &http.Request{355			Header: http.Header{356				ticketHeader: []string{"s3cr3t"},357				dapperHeader: []string{"trace-001"},358			},359		},360		apiURL: u,361	}362	req := &basepb.StringProto{363		Value: proto.String("Doctor Who"),364	}365	res := &basepb.StringProto{}366	var apiErr error367	avg := testing.AllocsPerRun(100, func() {368		ctx, _ := netcontext.WithTimeout(toContext(c), 100*time.Millisecond)369		if err := Call(ctx, "actordb", "LookupActor", req, res); err != nil && apiErr == nil {370			apiErr = err // get the first error only371		}372	})373	if apiErr != nil {374		t.Errorf("API call failed: %v", apiErr)375	}376	// Lots of room for improvement...377	const min, max float64 = 60, 86378	if avg < min || max < avg {379		t.Errorf("Allocations per API call = %g, want in [%g,%g]", avg, min, max)380	}381}382func launchHelperProcess(t *testing.T) (apiURL *url.URL, cleanup func()) {383	cmd := exec.Command(os.Args[0], "-test.run=TestHelperProcess")384	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}385	stdin, err := cmd.StdinPipe()386	if err != nil {387		t.Fatalf("StdinPipe: %v", err)388	}389	stdout, err := cmd.StdoutPipe()390	if err != nil {391		t.Fatalf("StdoutPipe: %v", err)392	}393	if err := cmd.Start(); err != nil {394		t.Fatalf("Starting helper process: %v", err)395	}396	scan := bufio.NewScanner(stdout)397	var u *url.URL398	for scan.Scan() {399		line := scan.Text()400		if hp := strings.TrimPrefix(line, helperProcessMagic); hp != line {401			var err error402			u, err = url.Parse(hp)403			if err != nil {404				t.Fatalf("Failed to parse %q: %v", hp, err)405			}406			break407		}408	}409	if err := scan.Err(); err != nil {410		t.Fatalf("Scanning helper process stdout: %v", err)411	}412	if u == nil {413		t.Fatal("Helper process never reported")414	}415	return u, func() {416		stdin.Close()417		if err := cmd.Wait(); err != nil {418			t.Errorf("Helper process did not exit cleanly: %v", err)419		}420	}421}422const helperProcessMagic = "A lovely helper process is listening at "423// This isn't a real test. It's used as a helper process.424func TestHelperProcess(*testing.T) {425	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {426		return427	}428	defer os.Exit(0)429	f := &fakeAPIHandler{}430	srv := httptest.NewServer(f)431	defer srv.Close()432	fmt.Println(helperProcessMagic + srv.URL + apiPath)433	// Wait for stdin to be closed.434	io.Copy(ioutil.Discard, os.Stdin)435}436func TestBackgroundContext(t *testing.T) {437	resetEnv := SetTestEnv()438	defer resetEnv()439	ctx, key := fromContext(BackgroundContext()), "X-Magic-Ticket-Header"440	if g, w := ctx.req.Header.Get(key), "my-app-id/default.20150612t184001.0"; g != w {441		t.Errorf("%v = %q, want %q", key, g, w)442	}443	// Check that using the background context doesn't panic.444	req := &basepb.StringProto{445		Value: proto.String("Doctor Who"),446	}447	res := &basepb.StringProto{}448	Call(BackgroundContext(), "actordb", "LookupActor", req, res) // expected to fail449}...

...30	p.Get("/foo/:name").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {31		ok = true32		st.Expect(t, r.URL.Query().Get(":name"), "keith")33	}))34	p.HandleHTTP(nil, newRequest("GET", "/foo/keith?a=b", nil), nil)35	if !ok {36		t.Error("handler not called")37	}38}39func TestRoutingMethodNotAllowed(t *testing.T) {40	p := New()41	p.ForceMethodNotAllowed = true42	var ok bool43	p.Post("/foo/:name").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {44		ok = true45	}))46	p.Put("/foo/:name").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {47		ok = true48	}))49	r := httptest.NewRecorder()50	var final bool51	p.HandleHTTP(r, newRequest("GET", "/foo/keith", nil), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {52		final = true53	}))54	st.Expect(t, ok, false)55	st.Expect(t, final, false)56	st.Expect(t, r.Code, http.StatusMethodNotAllowed)57	got := strings.Split(r.Header().Get("Allow"), ", ")58	sort.Strings(got)59	want := []string{"POST", "PUT"}60	st.Expect(t, got, want)61}62// Check to make sure we don't pollute the Raw Query when we have no parameters63func TestNoParams(t *testing.T) {64	p := New()65	var ok bool66	p.Get("/foo/").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {67		ok = true68		st.Expect(t, r.URL.RawQuery, "")69	}))70	p.HandleHTTP(nil, newRequest("GET", "/foo/", nil), nil)71	st.Expect(t, ok, true)72}73// Check to make sure we don't pollute the Raw Query when there are parameters but no pattern variables74func TestOnlyUserParams(t *testing.T) {75	p := New()76	var ok bool77	p.Get("/foo/").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {78		ok = true79		st.Expect(t, r.URL.RawQuery, "a=b")80	}))81	p.HandleHTTP(nil, newRequest("GET", "/foo/?a=b", nil), nil)82	st.Expect(t, ok, true)83}84func TestImplicitRedirect(t *testing.T) {85	p := New()86	p.Get("/foo/").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))87	res := httptest.NewRecorder()88	p.HandleHTTP(res, newRequest("GET", "/foo", nil), nil)89	st.Expect(t, res.Code, 200)90	st.Expect(t, res.Header().Get("Location"), "")91	p = New()92	p.Get("/foo").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))93	p.Get("/foo/").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))94	res = httptest.NewRecorder()95	p.HandleHTTP(res, newRequest("GET", "/foo", nil), nil)96	st.Expect(t, res.Code, 200)97	p = New()98	p.Get("/hello/:name/").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))99	res = httptest.NewRecorder()100	p.HandleHTTP(res, newRequest("GET", "/hello/bob?a=b#f", nil), nil)101	st.Expect(t, res.Code, 200)102}103func TestNotFound(t *testing.T) {104	p := New()105	p.NotFound = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {106		w.WriteHeader(123)107	})108	p.Post("/bar").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))109	for _, path := range []string{"/foo", "/bar"} {110		res := httptest.NewRecorder()111		p.HandleHTTP(res, newRequest("GET", path, nil), nil)112		st.Expect(t, res.Code, 123)113	}114}115func TestMethodPatch(t *testing.T) {116	p := New()117	p.Patch("/foo/bar").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))118	// Test to see if we get a 405 Method Not Allowed errors from trying to119	// issue a GET request to a handler that only supports the PATCH method.120	res := httptest.NewRecorder()121	res.Code = http.StatusMethodNotAllowed122	var final bool123	p.HandleHTTP(res, newRequest("GET", "/foo/bar", nil), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {124		final = true125	}))126	st.Expect(t, final, true)127	st.Expect(t, res.Code, http.StatusMethodNotAllowed)128	// Now, test to see if we get a 200 OK from issuing a PATCH request to129	// the same handler.130	res = httptest.NewRecorder()131	p.HandleHTTP(res, newRequest("PATCH", "/foo/bar", nil), nil)132	st.Expect(t, res.Code, http.StatusOK)133}134func BenchmarkPatternMatching(b *testing.B) {135	p := New()136	p.Get("/hello/:name").Handle(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))137	b.ResetTimer()138	for n := 0; n < b.N; n++ {139		b.StopTimer()140		r := newRequest("GET", "/hello/blake", nil)141		b.StartTimer()142		p.HandleHTTP(nil, r, nil)143	}144}145func newRequest(method, urlStr string, body io.Reader) *http.Request {146	req, err := http.NewRequest(method, urlStr, body)147	if err != nil {148		panic(err)149	}150	return req151}152func routeExists(r *Router, method, path string) bool {153	route, _ := r.FindRoute(method, path)154	return route != nil155}...

1package template2import (3	"net/http"4	"net/http/httptest"5	"strings"6	"testing"7)8func TestFormat(t *testing.T) {9	var reqHttp *http.Request10	handleHttp := func(rw http.ResponseWriter, r *http.Request) {11		reqHttp = r12	}13	svcHttp := httptest.NewServer(http.HandlerFunc(handleHttp))14	svcHttp.Client().Get(svcHttp.URL + "/path%20/to?q1=v1&q2=v2")15	svcHttp.Close()16	host := strings.TrimPrefix(svcHttp.URL, "http://")17	hostname, port := splitHostPort(host)18	var reqHttps *http.Request19	handleHttps := func(rw http.ResponseWriter, r *http.Request) {20		reqHttps = r21	}22	svcHttps := httptest.NewTLSServer(http.HandlerFunc(handleHttps))23	svcHttps.Client().Get(svcHttps.URL + "/path%20/to?q1=v1&q2=v2")24	svcHttps.Close()25	type args struct {26		format string27		r      *http.Request28	}29	tests := []struct {30		name    string31		args    args32		want    string33		wantErr bool34	}{35		{36			args: args{`{{.Scheme}}`, reqHttp},37			want: "http",38		},39		{40			args: args{`{{.Scheme}}`, reqHttps},41			want: "https",42		},43		{44			args: args{`{{.Host}}`, reqHttp},45			want: host,46		},47		{48			args: args{`{{.Hostname}}`, reqHttp},49			want: hostname,50		},51		{52			args: args{`{{.Port}}`, reqHttp},53			want: port,54		},55		{56			args: args{`{{.Path}}`, reqHttp},57			want: "/path /to",58		},59		{60			args: args{`{{.RawPath}}`, reqHttp},61			want: "/path%20/to",62		},63		{64			args: args{`{{.RawQuery}}`, reqHttp},65			want: "q1=v1&q2=v2",66		},67		{68			args: args{`{{.IsQuery}}`, reqHttp},69			want: "?",70		},71		{72			args: args{`{{.RequestURI}}`, reqHttp},73			want: "/path%20/to?q1=v1&q2=v2",74		},75		{76			args: args{`{{.Query "q1"}}`, reqHttp},77			want: "v1",78		},79		{80			args: args{`{{.Query "q2"}}`, reqHttp},81			want: "v2",82		},83		{84			args: args{`{{.Header "Accept-Encoding"}}`, reqHttp},85			want: "gzip",86		},87	}88	for _, tt := range tests {89		t.Run(tt.name, func(t *testing.T) {90			temp, err := NewFormat(tt.args.format)91			if err != nil {92				t.Errorf("newTemplate() error = %v", err)93				return94			}95			got := temp.FormatString(tt.args.r)96			if got != tt.want {97				t.Errorf("Format() got = %v, want %v", got, tt.want)98			}99		})100	}101}...

1import (2func (m got) ServeHTTP(w http.ResponseWriter, req *http.Request) {3	fmt.Fprintln(w, "Hello World")4}5func main() {6	http.ListenAndServe(":8080", g)7}

1import (2func main() {3    router := mux.NewRouter()4    router.HandleFunc("/", got.HandleHTTP).Methods("GET")5    http.ListenAndServe(":8080", router)6}7import (8func main() {9    router := mux.NewRouter()10    router.HandleFunc("/", got.HandleHTTP).Methods("GET")11    http.ListenAndServe(":8080", router)12}13import (14func main() {15    router := mux.NewRouter()16    got := got{}17    router.HandleFunc("/", got.HandleHTTP).Methods("GET")18    http.ListenAndServe(":8080", router)19}20import (21func main() {22    router := mux.NewRouter()23    got := got{}24    router.HandleFunc("/", got.HandleHTTP).Methods("GET")25    http.ListenAndServe(":8080", router)26}27import (28func main() {29    router := mux.NewRouter()30    got := got{}31    router.HandleFunc("/", got.HandleHTTP).Methods("GET")32    http.ListenAndServe(":8080", router)33}34import (

1import (2func main() {3	http.HandleFunc("/", got.HandleHTTP)4	http.ListenAndServe(":8080", nil)5}6import (7func main() {8	http.HandleFunc("/", got.HandleHTTP)9	http.ListenAndServe(":8080", nil)10}11import (12func main() {13	http.HandleFunc("/", got.HandleHTTP)14	http.ListenAndServe(":8080", nil)15}16import (17func main() {18	http.HandleFunc("/", got.HandleHTTP)19	http.ListenAndServe(":8080", nil)20}21import (22func main() {23	http.HandleFunc("/", got.HandleHTTP)24	http.ListenAndServe(":8080", nil)25}26import (27func main() {28	http.HandleFunc("/", got.HandleHTTP)29	http.ListenAndServe(":8080", nil)30}31import (32func main() {33	http.HandleFunc("/", got.HandleHTTP)34	http.ListenAndServe(":8080", nil)35}36import (37func main() {38	http.HandleFunc("/", got.HandleHTTP)39	http.ListenAndServe(":8080", nil)40}41import (42func main() {43	http.HandleFunc("/", got.HandleHTTP)44	http.ListenAndServe(":8080", nil)45}46import (47func main() {48	http.HandleFunc("/", got.HandleHTTP)49	http.ListenAndServe(":8080

1import (2func main() {3r := mux.NewRouter()4r.HandleFunc("/", got.HandleHTTP).Methods("GET")5http.ListenAndServe(":8080", r)6}7import (8func main() {9r := mux.NewRouter()10r.HandleFunc("/", got.HandleHTTP).Methods("GET")11http.ListenAndServe(":8080", r)12}13import (14var (15func init() {16got = NewGot()17}18func main() {19r := mux.NewRouter()20r.HandleFunc("/", got.HandleHTTP).Methods("GET")21http.ListenAndServe(":8080", r)22}23import (24var (25func init() {26got = NewGot()27}28func main() {29r := mux.NewRouter()30r.HandleFunc("/", got.HandleHTTP).Methods("GET")31http.ListenAndServe(":8080", r)32}33import (34func main() {35got := NewGot()36r := mux.NewRouter()37r.HandleFunc("/", got.HandleHTTP).Methods("GET")38http.ListenAndServe(":8080", r)39}40import (41func main() {

1import (2type got struct {3}4func (g got) ServeHTTP(w http.ResponseWriter, r *http.Request) {5    fmt.Fprintf(w, "Hello, %s", g.name)6}7func main() {8    g := got{name: "GOT"}9    http.Handle("/got", g)10    http.ListenAndServe(":8080", nil)11}12import (13func got(w http.ResponseWriter, r *http.Request) {14    fmt.Fprintf(w, "Hello, %s", "GOT")15}16func main() {17    http.HandleFunc("/got", got)18    http.ListenAndServe(":8080", nil)19}20import (21type got struct {22}23func (g got) ServeHTTP(w http.ResponseWriter, r *http.Request) {24    fmt.Fprintf(w, "Hello, %s", g.name)25}26func main() {27    g := got{name: "GOT"}28    http.Handle("/got", g)29    http.ListenAndServe(":8080", nil)30}31import (32type got struct {33}34func (g got) ServeHTTP(w http.ResponseWriter, r *http.Request) {35    fmt.Fprintf(w, "Hello, %s", g.name)36}37func main() {38    g := got{name: "GOT"}39    http.Handle("/got", g)40    http.ListenAndServe(":8080", nil)41}42import (43type got struct {44}45func (g got) ServeHTTP(w http.ResponseWriter, r *http.Request) {46    fmt.Fprintf(w, "Hello, %s", g.name)47}48func main() {49    g := got{name: "GOT"}50    http.Handle("/got", g)

1import (2func main() {3	http.HandleFunc("/", got.HandleHTTP)4	http.ListenAndServe(":8080", nil)5}6import (7func HandleHTTP(w http.ResponseWriter, r *http.Request) {8	fmt.Fprint(w, "Hello World")9}10import (11func HandleHTTP(w http.ResponseWriter, r *http.Request) {12	fmt.Fprint(w, "Hello World")13}14import (15func HandleHTTP(w http.ResponseWriter, r *http.Request) {16	fmt.Fprint(w, "Hello World")17}18import (19func HandleHTTP(w http.ResponseWriter, r *http.Request) {20	fmt.Fprint(w, "Hello World")21}22import (23func HandleHTTP(w http.ResponseWriter, r *http.Request) {24	fmt.Fprint(w, "Hello World")25}26import (27func HandleHTTP(w http.ResponseWriter, r *http.Request) {28	fmt.Fprint(w, "Hello World")29}30import (31func HandleHTTP(w http.ResponseWriter, r *http.Request) {32	fmt.Fprint(w, "Hello World")33}34import (35func HandleHTTP(w http.ResponseWriter, r *http.Request) {36	fmt.Fprint(w, "Hello World")37}

1import (2func main() {3	router := mux.NewRouter()4	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")5	http.ListenAndServe(":8000", router)6}7import (8func main() {9	router := mux.NewRouter()10	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")11	http.ListenAndServe(":8000", router)12}13import (14func main() {15	router := mux.NewRouter()16	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")17	http.ListenAndServe(":8000", router)18}19import (20func main() {21	router := mux.NewRouter()22	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")23	http.ListenAndServe(":8000", router)24}25import (26func main() {27	router := mux.NewRouter()28	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")29	http.ListenAndServe(":8000", router)30}31import (32func main() {33	router := mux.NewRouter()34	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")35	http.ListenAndServe(":8000", router)36}37import (38func main() {39	router := mux.NewRouter()40	router.HandleFunc("/hello", got.HandleHTTP).Methods("GET")41	http.ListenAndServe(":8000", router)42}

1import (2func main() {3	http.HandleFunc("/", got.HandleHTTP)4	http.ListenAndServe(":8080", nil)5}6import (7func main() {8	http.HandleFunc("/", got.HandleHTTP)9	http.ListenAndServe(":8080", nil)10}11import (12func main() {13	http.HandleFunc("/", got.HandleHTTP)14	http.ListenAndServe(":8080", nil)15}16import (17func main() {18	http.HandleFunc("/", got.HandleHTTP)19	http.ListenAndServe(":8080", nil)20}21import (22func main() {23	http.HandleFunc("/", got.HandleHTTP)24	http.ListenAndServe(":8080", nil)25}26import (27func main() {28	http.HandleFunc("/", got.HandleHTTP)29	http.ListenAndServe(":8080", nil)30}31import (32func main() {33	http.HandleFunc("/", got.HandleHTTP)34	http.ListenAndServe(":8080", nil)35}36import (37func main() {38	http.HandleFunc("/", got.HandleHTTP)39	http.ListenAndServe(":8080", nil)40}41import (42func main() {43	http.HandleFunc("/", got.HandleHTTP)44	http.ListenAndServe(":8080", nil)45}

1import (2func main() {3    router := mux.NewRouter()4    router.HandleFunc("/api", got.HandleHTTP)5    fmt.Println("Server is listening on port 8000")6    http.ListenAndServe(":8000", handlers.CORS()(router))7}8import (9func HandleHTTP(w http.ResponseWriter, r *http.Request) {10    w.Header().Set("Content-Type", "application/json")11    w.WriteHeader(http.StatusOK)12    fmt.Fprintf(w, `{"message": "Hello world"}`)13}

1import (2func main() {3    got.HandleHTTP()4    fmt.Println("Hello!")5}6import (7func main() {8    got.HandleHTTP()9    fmt.Println("Hello!")10}11    /usr/local/go/src/github.com/abc/got (from $GOROOT)12    /home/abc/go/src/github.com/abc/got (from $GOPATH)13SELECT COUNT(*) FROM table_name;14SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public';15LINE 1: CREATE TABLE IF NOT EXISTS users (16CREATE TABLE IF NOT EXISTS users (17);18CREATE TABLE IF NOT EXISTS users (19) IF NOT EXISTS;20LINE 1: CREATE TABLE IF NOT EXISTS users (21CREATE TABLE IF NOT EXISTS users (22);