src/pkg/rpc/server_test.go - go - Git at Google

 // 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 rpc

 import (
 	"fmt"
 	"http"
 	"log"
 	"net"
 	"os"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 )

 var (
 	serverAddr, newServerAddr string
 	httpServerAddr            string
 	once, newOnce, httpOnce   sync.Once
 )

 const (
 	second      = 1e9
 	newHttpPath = "/foo"
 )

 type Args struct {
 	A, B int
 }

 type Reply struct {
 	C int
 }

 type Arith int

 func (t *Arith) Add(args *Args, reply *Reply) os.Error {
 	reply.C = args.A + args.B
 	return nil
 }

 func (t *Arith) Mul(args *Args, reply *Reply) os.Error {
 	reply.C = args.A * args.B
 	return nil
 }

 func (t *Arith) Div(args *Args, reply *Reply) os.Error {
 	if args.B == 0 {
 		return os.ErrorString("divide by zero")
 	}
 	reply.C = args.A / args.B
 	return nil
 }

 func (t *Arith) String(args *Args, reply *string) os.Error {
 	*reply = fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
 	return nil
 }

 func (t *Arith) Scan(args *string, reply *Reply) (err os.Error) {
 	_, err = fmt.Sscan(*args, &reply.C)
 	return
 }

 func (t *Arith) Error(args *Args, reply *Reply) os.Error {
 	panic("ERROR")
 }

 func listenTCP() (net.Listener, string) {
 	l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
 	if e != nil {
 		log.Exitf("net.Listen tcp :0: %v", e)
 	}
 	return l, l.Addr().String()
 }

 func startServer() {
 	Register(new(Arith))

 	var l net.Listener
 	l, serverAddr = listenTCP()
 	log.Println("Test RPC server listening on", serverAddr)
 	go Accept(l)

 	HandleHTTP()
 	httpOnce.Do(startHttpServer)
 }

 func startNewServer() {
 	s := NewServer()
 	s.Register(new(Arith))

 	var l net.Listener
 	l, newServerAddr = listenTCP()
 	log.Println("NewServer test RPC server listening on", newServerAddr)
 	go Accept(l)

 	s.HandleHTTP(newHttpPath, "/bar")
 	httpOnce.Do(startHttpServer)
 }

 func startHttpServer() {
 	var l net.Listener
 	l, httpServerAddr = listenTCP()
 	httpServerAddr = l.Addr().String()
 	log.Println("Test HTTP RPC server listening on", httpServerAddr)
 	go http.Serve(l, nil)
 }

 func TestRPC(t *testing.T) {
 	once.Do(startServer)
 	testRPC(t, serverAddr)
 	newOnce.Do(startNewServer)
 	testRPC(t, newServerAddr)
 }

 func testRPC(t *testing.T, addr string) {
 	client, err := Dial("tcp", addr)
 	if err != nil {
 		t.Fatal("dialing", err)
 	}

 	// Synchronous calls
 	args := &Args{7, 8}
 	reply := new(Reply)
 	err = client.Call("Arith.Add", args, reply)
 	if err != nil {
 		t.Errorf("Add: expected no error but got string %q", err.String())
 	}
 	if reply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
 	}

 	args = &Args{7, 8}
 	reply = new(Reply)
 	err = client.Call("Arith.Mul", args, reply)
 	if err != nil {
 		t.Errorf("Mul: expected no error but got string %q", err.String())
 	}
 	if reply.C != args.A*args.B {
 		t.Errorf("Mul: expected %d got %d", reply.C, args.A*args.B)
 	}

 	// Out of order.
 	args = &Args{7, 8}
 	mulReply := new(Reply)
 	mulCall := client.Go("Arith.Mul", args, mulReply, nil)
 	addReply := new(Reply)
 	addCall := client.Go("Arith.Add", args, addReply, nil)

 	addCall = <-addCall.Done
 	if addCall.Error != nil {
 		t.Errorf("Add: expected no error but got string %q", addCall.Error.String())
 	}
 	if addReply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", addReply.C, args.A+args.B)
 	}

 	mulCall = <-mulCall.Done
 	if mulCall.Error != nil {
 		t.Errorf("Mul: expected no error but got string %q", mulCall.Error.String())
 	}
 	if mulReply.C != args.A*args.B {
 		t.Errorf("Mul: expected %d got %d", mulReply.C, args.A*args.B)
 	}

 	// Error test
 	args = &Args{7, 0}
 	reply = new(Reply)
 	err = client.Call("Arith.Div", args, reply)
 	// expect an error: zero divide
 	if err == nil {
 		t.Error("Div: expected error")
 	} else if err.String() != "divide by zero" {
 		t.Error("Div: expected divide by zero error; got", err)
 	}

 	// Non-struct argument
 	const Val = 12345
 	str := fmt.Sprint(Val)
 	reply = new(Reply)
 	err = client.Call("Arith.Scan", &str, reply)
 	if err != nil {
 		t.Errorf("Scan: expected no error but got string %q", err.String())
 	} else if reply.C != Val {
 		t.Errorf("Scan: expected %d got %d", Val, reply.C)
 	}

 	// Non-struct reply
 	args = &Args{27, 35}
 	str = ""
 	err = client.Call("Arith.String", args, &str)
 	if err != nil {
 		t.Errorf("String: expected no error but got string %q", err.String())
 	}
 	expect := fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
 	if str != expect {
 		t.Errorf("String: expected %s got %s", expect, str)
 	}
 }

 func TestHTTPRPC(t *testing.T) {
 	once.Do(startServer)
 	testHTTPRPC(t, "")
 	newOnce.Do(startNewServer)
 	testHTTPRPC(t, newHttpPath)
 }

 func testHTTPRPC(t *testing.T, path string) {
 	var client *Client
 	var err os.Error
 	if path == "" {
 		client, err = DialHTTP("tcp", httpServerAddr)
 	} else {
 		client, err = DialHTTPPath("tcp", httpServerAddr, path)
 	}
 	if err != nil {
 		t.Fatal("dialing", err)
 	}

 	// Synchronous calls
 	args := &Args{7, 8}
 	reply := new(Reply)
 	err = client.Call("Arith.Add", args, reply)
 	if err != nil {
 		t.Errorf("Add: expected no error but got string %q", err.String())
 	}
 	if reply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
 	}
 }

 func TestCheckUnknownService(t *testing.T) {
 	once.Do(startServer)

 	conn, err := net.Dial("tcp", "", serverAddr)
 	if err != nil {
 		t.Fatal("dialing:", err)
 	}

 	client := NewClient(conn)

 	args := &Args{7, 8}
 	reply := new(Reply)
 	err = client.Call("Unknown.Add", args, reply)
 	if err == nil {
 		t.Error("expected error calling unknown service")
 	} else if strings.Index(err.String(), "service") < 0 {
 		t.Error("expected error about service; got", err)
 	}
 }

 func TestCheckUnknownMethod(t *testing.T) {
 	once.Do(startServer)

 	conn, err := net.Dial("tcp", "", serverAddr)
 	if err != nil {
 		t.Fatal("dialing:", err)
 	}

 	client := NewClient(conn)

 	args := &Args{7, 8}
 	reply := new(Reply)
 	err = client.Call("Arith.Unknown", args, reply)
 	if err == nil {
 		t.Error("expected error calling unknown service")
 	} else if strings.Index(err.String(), "method") < 0 {
 		t.Error("expected error about method; got", err)
 	}
 }

 func TestCheckBadType(t *testing.T) {
 	once.Do(startServer)

 	conn, err := net.Dial("tcp", "", serverAddr)
 	if err != nil {
 		t.Fatal("dialing:", err)
 	}

 	client := NewClient(conn)

 	reply := new(Reply)
 	err = client.Call("Arith.Add", reply, reply) // args, reply would be the correct thing to use
 	if err == nil {
 		t.Error("expected error calling Arith.Add with wrong arg type")
 	} else if strings.Index(err.String(), "type") < 0 {
 		t.Error("expected error about type; got", err)
 	}
 }

 type ArgNotPointer int
 type ReplyNotPointer int
 type ArgNotPublic int
 type ReplyNotPublic int
 type local struct{}

 func (t *ArgNotPointer) ArgNotPointer(args Args, reply *Reply) os.Error {
 	return nil
 }

 func (t *ReplyNotPointer) ReplyNotPointer(args *Args, reply Reply) os.Error {
 	return nil
 }

 func (t *ArgNotPublic) ArgNotPublic(args *local, reply *Reply) os.Error {
 	return nil
 }

 func (t *ReplyNotPublic) ReplyNotPublic(args *Args, reply *local) os.Error {
 	return nil
 }

 // Check that registration handles lots of bad methods and a type with no suitable methods.
 func TestRegistrationError(t *testing.T) {
 	err := Register(new(ArgNotPointer))
 	if err == nil {
 		t.Errorf("expected error registering ArgNotPointer")
 	}
 	err = Register(new(ReplyNotPointer))
 	if err == nil {
 		t.Errorf("expected error registering ReplyNotPointer")
 	}
 	err = Register(new(ArgNotPublic))
 	if err == nil {
 		t.Errorf("expected error registering ArgNotPublic")
 	}
 	err = Register(new(ReplyNotPublic))
 	if err == nil {
 		t.Errorf("expected error registering ReplyNotPublic")
 	}
 }

 type WriteFailCodec int

 func (WriteFailCodec) WriteRequest(*Request, interface{}) os.Error {
 	// the panic caused by this error used to not unlock a lock.
 	return os.NewError("fail")
 }

 func (WriteFailCodec) ReadResponseHeader(*Response) os.Error {
 	time.Sleep(60e9)
 	panic("unreachable")
 }

 func (WriteFailCodec) ReadResponseBody(interface{}) os.Error {
 	time.Sleep(60e9)
 	panic("unreachable")
 }

 func (WriteFailCodec) Close() os.Error {
 	return nil
 }

 func TestSendDeadlock(t *testing.T) {
 	client := NewClientWithCodec(WriteFailCodec(0))

 	done := make(chan bool)
 	go func() {
 		testSendDeadlock(client)
 		testSendDeadlock(client)
 		done <- true
 	}()
 	for i := 0; i < 50; i++ {
 		time.Sleep(100 * 1e6)
 		_, ok := <-done
 		if ok {
 			return
 		}
 	}
 	t.Fatal("deadlock")
 }

 func testSendDeadlock(client *Client) {
 	defer func() {
 		recover()
 	}()
 	args := &Args{7, 8}
 	reply := new(Reply)
 	client.Call("Arith.Add", args, reply)
 }
	// 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 rpc

	import (
	"fmt"
	"http"
	"log"
	"net"
	"os"
	"strings"
	"sync"
	"testing"
	"time"
	)

	var (
	serverAddr, newServerAddr string
	httpServerAddr string
	once, newOnce, httpOnce sync.Once
	)

	const (
	second = 1e9
	newHttpPath = "/foo"
	)

	type Args struct {
	A, B int
	}

	type Reply struct {
	C int
	}

	type Arith int

	func (t Arith) Add(args Args, reply *Reply) os.Error {
	reply.C = args.A + args.B
	return nil
	}

	func (t Arith) Mul(args Args, reply *Reply) os.Error {
	reply.C = args.A * args.B
	return nil
	}

	func (t Arith) Div(args Args, reply *Reply) os.Error {
	if args.B == 0 {
	return os.ErrorString("divide by zero")
	}
	reply.C = args.A / args.B
	return nil
	}

	func (t Arith) String(args Args, reply *string) os.Error {
	*reply = fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
	return nil
	}

	func (t Arith) Scan(args string, reply *Reply) (err os.Error) {
	_, err = fmt.Sscan(*args, &reply.C)
	return
	}

	func (t Arith) Error(args Args, reply *Reply) os.Error {
	panic("ERROR")
	}

	func listenTCP() (net.Listener, string) {
	l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
	if e != nil {
	log.Exitf("net.Listen tcp :0: %v", e)
	}
	return l, l.Addr().String()
	}

	func startServer() {
	Register(new(Arith))

	var l net.Listener
	l, serverAddr = listenTCP()
	log.Println("Test RPC server listening on", serverAddr)
	go Accept(l)

	HandleHTTP()
	httpOnce.Do(startHttpServer)
	}

	func startNewServer() {
	s := NewServer()
	s.Register(new(Arith))

	var l net.Listener
	l, newServerAddr = listenTCP()
	log.Println("NewServer test RPC server listening on", newServerAddr)
	go Accept(l)

	s.HandleHTTP(newHttpPath, "/bar")
	httpOnce.Do(startHttpServer)
	}

	func startHttpServer() {
	var l net.Listener
	l, httpServerAddr = listenTCP()
	httpServerAddr = l.Addr().String()
	log.Println("Test HTTP RPC server listening on", httpServerAddr)
	go http.Serve(l, nil)
	}

	func TestRPC(t *testing.T) {
	once.Do(startServer)
	testRPC(t, serverAddr)
	newOnce.Do(startNewServer)
	testRPC(t, newServerAddr)
	}

	func testRPC(t *testing.T, addr string) {
	client, err := Dial("tcp", addr)
	if err != nil {
	t.Fatal("dialing", err)
	}

	// Synchronous calls
	args := &Args{7, 8}
	reply := new(Reply)
	err = client.Call("Arith.Add", args, reply)
	if err != nil {
	t.Errorf("Add: expected no error but got string %q", err.String())
	}
	if reply.C != args.A+args.B {
	t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
	}

	args = &Args{7, 8}
	reply = new(Reply)
	err = client.Call("Arith.Mul", args, reply)
	if err != nil {
	t.Errorf("Mul: expected no error but got string %q", err.String())
	}
	if reply.C != args.A*args.B {
	t.Errorf("Mul: expected %d got %d", reply.C, args.A*args.B)
	}

	// Out of order.
	args = &Args{7, 8}
	mulReply := new(Reply)
	mulCall := client.Go("Arith.Mul", args, mulReply, nil)
	addReply := new(Reply)
	addCall := client.Go("Arith.Add", args, addReply, nil)

	addCall = <-addCall.Done
	if addCall.Error != nil {
	t.Errorf("Add: expected no error but got string %q", addCall.Error.String())
	}
	if addReply.C != args.A+args.B {
	t.Errorf("Add: expected %d got %d", addReply.C, args.A+args.B)
	}

	mulCall = <-mulCall.Done
	if mulCall.Error != nil {
	t.Errorf("Mul: expected no error but got string %q", mulCall.Error.String())
	}
	if mulReply.C != args.A*args.B {
	t.Errorf("Mul: expected %d got %d", mulReply.C, args.A*args.B)
	}

	// Error test
	args = &Args{7, 0}
	reply = new(Reply)
	err = client.Call("Arith.Div", args, reply)
	// expect an error: zero divide
	if err == nil {
	t.Error("Div: expected error")
	} else if err.String() != "divide by zero" {
	t.Error("Div: expected divide by zero error; got", err)
	}

	// Non-struct argument
	const Val = 12345
	str := fmt.Sprint(Val)
	reply = new(Reply)
	err = client.Call("Arith.Scan", &str, reply)
	if err != nil {
	t.Errorf("Scan: expected no error but got string %q", err.String())
	} else if reply.C != Val {
	t.Errorf("Scan: expected %d got %d", Val, reply.C)
	}

	// Non-struct reply
	args = &Args{27, 35}
	str = ""
	err = client.Call("Arith.String", args, &str)
	if err != nil {
	t.Errorf("String: expected no error but got string %q", err.String())
	}
	expect := fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
	if str != expect {
	t.Errorf("String: expected %s got %s", expect, str)
	}
	}

	func TestHTTPRPC(t *testing.T) {
	once.Do(startServer)
	testHTTPRPC(t, "")
	newOnce.Do(startNewServer)
	testHTTPRPC(t, newHttpPath)
	}

	func testHTTPRPC(t *testing.T, path string) {
	var client *Client
	var err os.Error
	if path == "" {
	client, err = DialHTTP("tcp", httpServerAddr)
	} else {
	client, err = DialHTTPPath("tcp", httpServerAddr, path)
	}
	if err != nil {
	t.Fatal("dialing", err)
	}

	// Synchronous calls
	args := &Args{7, 8}
	reply := new(Reply)
	err = client.Call("Arith.Add", args, reply)
	if err != nil {
	t.Errorf("Add: expected no error but got string %q", err.String())
	}
	if reply.C != args.A+args.B {
	t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
	}
	}

	func TestCheckUnknownService(t *testing.T) {
	once.Do(startServer)

	conn, err := net.Dial("tcp", "", serverAddr)
	if err != nil {
	t.Fatal("dialing:", err)
	}

	client := NewClient(conn)

	args := &Args{7, 8}
	reply := new(Reply)
	err = client.Call("Unknown.Add", args, reply)
	if err == nil {
	t.Error("expected error calling unknown service")
	} else if strings.Index(err.String(), "service") < 0 {
	t.Error("expected error about service; got", err)
	}
	}

	func TestCheckUnknownMethod(t *testing.T) {
	once.Do(startServer)

	conn, err := net.Dial("tcp", "", serverAddr)
	if err != nil {
	t.Fatal("dialing:", err)
	}

	client := NewClient(conn)

	args := &Args{7, 8}
	reply := new(Reply)
	err = client.Call("Arith.Unknown", args, reply)
	if err == nil {
	t.Error("expected error calling unknown service")
	} else if strings.Index(err.String(), "method") < 0 {
	t.Error("expected error about method; got", err)
	}
	}

	func TestCheckBadType(t *testing.T) {
	once.Do(startServer)

	conn, err := net.Dial("tcp", "", serverAddr)
	if err != nil {
	t.Fatal("dialing:", err)
	}

	client := NewClient(conn)

	reply := new(Reply)
	err = client.Call("Arith.Add", reply, reply) // args, reply would be the correct thing to use
	if err == nil {
	t.Error("expected error calling Arith.Add with wrong arg type")
	} else if strings.Index(err.String(), "type") < 0 {
	t.Error("expected error about type; got", err)
	}
	}

	type ArgNotPointer int
	type ReplyNotPointer int
	type ArgNotPublic int
	type ReplyNotPublic int
	type local struct{}

	func (t ArgNotPointer) ArgNotPointer(args Args, reply Reply) os.Error {
	return nil
	}

	func (t ReplyNotPointer) ReplyNotPointer(args Args, reply Reply) os.Error {
	return nil
	}

	func (t ArgNotPublic) ArgNotPublic(args local, reply *Reply) os.Error {
	return nil
	}

	func (t ReplyNotPublic) ReplyNotPublic(args Args, reply *local) os.Error {
	return nil
	}

	// Check that registration handles lots of bad methods and a type with no suitable methods.
	func TestRegistrationError(t *testing.T) {
	err := Register(new(ArgNotPointer))
	if err == nil {
	t.Errorf("expected error registering ArgNotPointer")
	}
	err = Register(new(ReplyNotPointer))
	if err == nil {
	t.Errorf("expected error registering ReplyNotPointer")
	}
	err = Register(new(ArgNotPublic))
	if err == nil {
	t.Errorf("expected error registering ArgNotPublic")
	}
	err = Register(new(ReplyNotPublic))
	if err == nil {
	t.Errorf("expected error registering ReplyNotPublic")
	}
	}

	type WriteFailCodec int

	func (WriteFailCodec) WriteRequest(*Request, interface{}) os.Error {
	// the panic caused by this error used to not unlock a lock.
	return os.NewError("fail")
	}

	func (WriteFailCodec) ReadResponseHeader(*Response) os.Error {
	time.Sleep(60e9)
	panic("unreachable")
	}

	func (WriteFailCodec) ReadResponseBody(interface{}) os.Error {
	time.Sleep(60e9)
	panic("unreachable")
	}

	func (WriteFailCodec) Close() os.Error {
	return nil
	}

	func TestSendDeadlock(t *testing.T) {
	client := NewClientWithCodec(WriteFailCodec(0))

	done := make(chan bool)
	go func() {
	testSendDeadlock(client)
	testSendDeadlock(client)
	done <- true
	}()
	for i := 0; i < 50; i++ {
	time.Sleep(100 * 1e6)
	_, ok := <-done
	if ok {
	return
	}
	}
	t.Fatal("deadlock")
	}

	func testSendDeadlock(client *Client) {
	defer func() {
	recover()
	}()
	args := &Args{7, 8}
	reply := new(Reply)
	client.Call("Arith.Add", args, reply)
	}