go/src/net/rpc/server_test.go

var newServer

var (
	serverAddr
	newServerAddr
)

var httpServerAddr

var (
	once
	newOnce
	httpOnce
)

const newHttpPath

type Args

type Reply

type Arith

func (t *Arith) Add(args Args, reply *Reply) error {}

func (t *Arith) Mul(args *Args, reply *Reply) error {}

func (t *Arith) Div(args Args, reply *Reply) error {}

func (t *Arith) String(args *Args, reply *string) error {}

func (t *Arith) Scan(args string, reply *Reply) (err error) {}

func (t *Arith) Error(args *Args, reply *Reply) error {}

func (t *Arith) SleepMilli(args *Args, reply *Reply) error {}

type hidden

func (t *hidden) Exported(args Args, reply *Reply) error {}

type Embed

type BuiltinTypes

func (BuiltinTypes) Map(args *Args, reply *map[int]int) error {}

func (BuiltinTypes) Slice(args *Args, reply *[]int) error {}

func (BuiltinTypes) Array(args *Args, reply *[2]int) error {}

func listenTCP() (net.Listener, string) {}

func startServer() {}

func startNewServer() {}

func startHttpServer() {}

func TestRPC(t *testing.T) {}

func testRPC(t *testing.T, addr string) {}

func testNewServerRPC(t *testing.T, addr string) {}

func TestHTTP(t *testing.T) {}

func testHTTPRPC(t *testing.T, path string) {}

func TestBuiltinTypes(t *testing.T) {}

type CodecEmulator

func (codec *CodecEmulator) Call(serviceMethod string, args *Args, reply *Reply) error {}

func (codec *CodecEmulator) ReadRequestHeader(req *Request) error {}

func (codec *CodecEmulator) ReadRequestBody(argv any) error {}

func (codec *CodecEmulator) WriteResponse(resp *Response, reply any) error {}

func (codec *CodecEmulator) Close() error {}

func TestServeRequest(t *testing.T) {}

func testServeRequest(t *testing.T, server *Server) {}

type ReplyNotPointer

type ArgNotPublic

type ReplyNotPublic

type NeedsPtrType

type local

func (t *ReplyNotPointer) ReplyNotPointer(args *Args, reply Reply) error {}

func (t *ArgNotPublic) ArgNotPublic(args *local, reply *Reply) error {}

func (t *ReplyNotPublic) ReplyNotPublic(args *Args, reply *local) error {}

func (t *NeedsPtrType) NeedsPtrType(args *Args, reply *Reply) error {}

// Check that registration handles lots of bad methods and a type with no suitable methods.
func TestRegistrationError(t *testing.T) {}

type WriteFailCodec

func (WriteFailCodec) WriteRequest(*Request, any) error {}

func (WriteFailCodec) ReadResponseHeader(*Response) error {}

func (WriteFailCodec) ReadResponseBody(any) error {}

func (WriteFailCodec) Close() error {}

func TestSendDeadlock(t *testing.T) {}

func testSendDeadlock(client *Client) {}

func dialDirect() (*Client, error) {}

func dialHTTP() (*Client, error) {}

func countMallocs(dial func() (*Client, error), t *testing.T) float64 {}

func TestCountMallocs(t *testing.T) {}

func TestCountMallocsOverHTTP(t *testing.T) {}

type writeCrasher

func (writeCrasher) Close() error {}

func (w *writeCrasher) Read(p []byte) (int, error) {}

func (writeCrasher) Write(p []byte) (int, error) {}

func TestClientWriteError(t *testing.T) {}

func TestTCPClose(t *testing.T) {}

func TestErrorAfterClientClose(t *testing.T) {}

// Tests the fix to issue 11221. Without the fix, this loops forever or crashes.
func TestAcceptExitAfterListenerClose(t *testing.T) {}

func TestShutdown(t *testing.T) {}

func benchmarkEndToEnd(dial func() (*Client, error), b *testing.B) {}

func benchmarkEndToEndAsync(dial func() (*Client, error), b *testing.B) {}

func BenchmarkEndToEnd(b *testing.B) {}

func BenchmarkEndToEndHTTP(b *testing.B) {}

func BenchmarkEndToEndAsync(b *testing.B) {}

func BenchmarkEndToEndAsyncHTTP(b *testing.B) {}