update vendor

Signed-off-by: Jess Frazelle <acidburn@microsoft.com>

vendor/google.golang.org/grpc/interop/alts/client/client.go

@@ -0,0 +1,65 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// This binary can only run on Google Cloud Platform (GCP).
+package main
+
+import (
+	"flag"
+	"time"
+
+	"golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/alts"
+	"google.golang.org/grpc/grpclog"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+)
+
+var (
+	hsAddr     = flag.String("alts_handshaker_service_address", "", "ALTS handshaker gRPC service address")
+	serverAddr = flag.String("server_address", ":8080", "The port on which the server is listening")
+)
+
+func main() {
+	flag.Parse()
+
+	opts := alts.DefaultClientOptions()
+	if *hsAddr != "" {
+		opts.HandshakerServiceAddress = *hsAddr
+	}
+	altsTC := alts.NewClientCreds(opts)
+	// Block until the server is ready.
+	conn, err := grpc.Dial(*serverAddr, grpc.WithTransportCredentials(altsTC), grpc.WithBlock())
+	if err != nil {
+		grpclog.Fatalf("gRPC Client: failed to dial the server at %v: %v", *serverAddr, err)
+	}
+	defer conn.Close()
+	grpcClient := testpb.NewTestServiceClient(conn)
+
+	// Call the EmptyCall API.
+	ctx := context.Background()
+	request := &testpb.Empty{}
+	if _, err := grpcClient.EmptyCall(ctx, request); err != nil {
+		grpclog.Fatalf("grpc Client: EmptyCall(_, %v) failed: %v", request, err)
+	}
+	grpclog.Info("grpc Client: empty call succeeded")
+
+	// This sleep prevents the connection from being abruptly disconnected
+	// when running this binary (along with grpc_server) on GCP dev cluster.
+	time.Sleep(1 * time.Second)
+}

vendor/google.golang.org/grpc/interop/alts/server/server.go

@@ -0,0 +1,53 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// This binary can only run on Google Cloud Platform (GCP).
+package main
+
+import (
+	"flag"
+	"net"
+
+	grpc "google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/alts"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/interop"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+)
+
+var (
+	hsAddr     = flag.String("alts_handshaker_service_address", "", "ALTS handshaker gRPC service address")
+	serverAddr = flag.String("server_address", ":8080", "The port on which the server is listening")
+)
+
+func main() {
+	flag.Parse()
+
+	lis, err := net.Listen("tcp", *serverAddr)
+	if err != nil {
+		grpclog.Fatalf("gRPC Server: failed to start the server at %v: %v", *serverAddr, err)
+	}
+	opts := alts.DefaultServerOptions()
+	if *hsAddr != "" {
+		opts.HandshakerServiceAddress = *hsAddr
+	}
+	altsTC := alts.NewServerCreds(opts)
+	grpcServer := grpc.NewServer(grpc.Creds(altsTC))
+	testpb.RegisterTestServiceServer(grpcServer, interop.NewTestServer())
+	grpcServer.Serve(lis)
+}

vendor/google.golang.org/grpc/interop/client/client.go

@@ -0,0 +1,212 @@
+/*
+ *
+ * Copyright 2014 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package main
+
+import (
+	"flag"
+	"net"
+	"strconv"
+
+	"google.golang.org/grpc"
+	_ "google.golang.org/grpc/balancer/grpclb"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/alts"
+	"google.golang.org/grpc/credentials/oauth"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/interop"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+	"google.golang.org/grpc/resolver"
+	"google.golang.org/grpc/testdata"
+)
+
+var (
+	caFile                = flag.String("ca_file", "", "The file containning the CA root cert file")
+	useTLS                = flag.Bool("use_tls", false, "Connection uses TLS if true")
+	useALTS               = flag.Bool("use_alts", false, "Connection uses ALTS if true (this option can only be used on GCP)")
+	altsHSAddr            = flag.String("alts_handshaker_service_address", "", "ALTS handshaker gRPC service address")
+	testCA                = flag.Bool("use_test_ca", false, "Whether to replace platform root CAs with test CA as the CA root")
+	serviceAccountKeyFile = flag.String("service_account_key_file", "", "Path to service account json key file")
+	oauthScope            = flag.String("oauth_scope", "", "The scope for OAuth2 tokens")
+	defaultServiceAccount = flag.String("default_service_account", "", "Email of GCE default service account")
+	serverHost            = flag.String("server_host", "localhost", "The server host name")
+	serverPort            = flag.Int("server_port", 10000, "The server port number")
+	tlsServerName         = flag.String("server_host_override", "", "The server name use to verify the hostname returned by TLS handshake if it is not empty. Otherwise, --server_host is used.")
+	testCase              = flag.String("test_case", "large_unary",
+		`Configure different test cases. Valid options are:
+        empty_unary : empty (zero bytes) request and response;
+        large_unary : single request and (large) response;
+        client_streaming : request streaming with single response;
+        server_streaming : single request with response streaming;
+        ping_pong : full-duplex streaming;
+        empty_stream : full-duplex streaming with zero message;
+        timeout_on_sleeping_server: fullduplex streaming on a sleeping server;
+        compute_engine_creds: large_unary with compute engine auth;
+        service_account_creds: large_unary with service account auth;
+        jwt_token_creds: large_unary with jwt token auth;
+        per_rpc_creds: large_unary with per rpc token;
+        oauth2_auth_token: large_unary with oauth2 token auth;
+        cancel_after_begin: cancellation after metadata has been sent but before payloads are sent;
+        cancel_after_first_response: cancellation after receiving 1st message from the server;
+        status_code_and_message: status code propagated back to client;
+        special_status_message: Unicode and whitespace is correctly processed in status message;
+        custom_metadata: server will echo custom metadata;
+        unimplemented_method: client attempts to call unimplemented method;
+        unimplemented_service: client attempts to call unimplemented service.`)
+)
+
+func main() {
+	flag.Parse()
+	resolver.SetDefaultScheme("dns")
+	if *useTLS && *useALTS {
+		grpclog.Fatalf("use_tls and use_alts cannot be both set to true")
+	}
+	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
+	var opts []grpc.DialOption
+	if *useTLS {
+		var sn string
+		if *tlsServerName != "" {
+			sn = *tlsServerName
+		}
+		var creds credentials.TransportCredentials
+		if *testCA {
+			var err error
+			if *caFile == "" {
+				*caFile = testdata.Path("ca.pem")
+			}
+			creds, err = credentials.NewClientTLSFromFile(*caFile, sn)
+			if err != nil {
+				grpclog.Fatalf("Failed to create TLS credentials %v", err)
+			}
+		} else {
+			creds = credentials.NewClientTLSFromCert(nil, sn)
+		}
+		opts = append(opts, grpc.WithTransportCredentials(creds))
+	} else if *useALTS {
+		altsOpts := alts.DefaultClientOptions()
+		if *altsHSAddr != "" {
+			altsOpts.HandshakerServiceAddress = *altsHSAddr
+		}
+		altsTC := alts.NewClientCreds(altsOpts)
+		opts = append(opts, grpc.WithTransportCredentials(altsTC))
+	} else {
+		opts = append(opts, grpc.WithInsecure())
+	}
+	if *useTLS || *useALTS {
+		if *testCase == "compute_engine_creds" {
+			opts = append(opts, grpc.WithPerRPCCredentials(oauth.NewComputeEngine()))
+		} else if *testCase == "service_account_creds" {
+			jwtCreds, err := oauth.NewServiceAccountFromFile(*serviceAccountKeyFile, *oauthScope)
+			if err != nil {
+				grpclog.Fatalf("Failed to create JWT credentials: %v", err)
+			}
+			opts = append(opts, grpc.WithPerRPCCredentials(jwtCreds))
+		} else if *testCase == "jwt_token_creds" {
+			jwtCreds, err := oauth.NewJWTAccessFromFile(*serviceAccountKeyFile)
+			if err != nil {
+				grpclog.Fatalf("Failed to create JWT credentials: %v", err)
+			}
+			opts = append(opts, grpc.WithPerRPCCredentials(jwtCreds))
+		} else if *testCase == "oauth2_auth_token" {
+			opts = append(opts, grpc.WithPerRPCCredentials(oauth.NewOauthAccess(interop.GetToken(*serviceAccountKeyFile, *oauthScope))))
+		}
+	}
+	opts = append(opts, grpc.WithBlock())
+	conn, err := grpc.Dial(serverAddr, opts...)
+	if err != nil {
+		grpclog.Fatalf("Fail to dial: %v", err)
+	}
+	defer conn.Close()
+	tc := testpb.NewTestServiceClient(conn)
+	switch *testCase {
+	case "empty_unary":
+		interop.DoEmptyUnaryCall(tc)
+		grpclog.Infoln("EmptyUnaryCall done")
+	case "large_unary":
+		interop.DoLargeUnaryCall(tc)
+		grpclog.Infoln("LargeUnaryCall done")
+	case "client_streaming":
+		interop.DoClientStreaming(tc)
+		grpclog.Infoln("ClientStreaming done")
+	case "server_streaming":
+		interop.DoServerStreaming(tc)
+		grpclog.Infoln("ServerStreaming done")
+	case "ping_pong":
+		interop.DoPingPong(tc)
+		grpclog.Infoln("Pingpong done")
+	case "empty_stream":
+		interop.DoEmptyStream(tc)
+		grpclog.Infoln("Emptystream done")
+	case "timeout_on_sleeping_server":
+		interop.DoTimeoutOnSleepingServer(tc)
+		grpclog.Infoln("TimeoutOnSleepingServer done")
+	case "compute_engine_creds":
+		if !*useTLS && !*useALTS {
+			grpclog.Fatalf("Neither TLS or ALTS are enabled. TLS or ALTS is required to execute compute_engine_creds test case.")
+		}
+		interop.DoComputeEngineCreds(tc, *defaultServiceAccount, *oauthScope)
+		grpclog.Infoln("ComputeEngineCreds done")
+	case "service_account_creds":
+		if !*useTLS && !*useALTS {
+			grpclog.Fatalf("Neither TLS or ALTS are enabled. TLS or ALTS is required to execute service_account_creds test case.")
+		}
+		interop.DoServiceAccountCreds(tc, *serviceAccountKeyFile, *oauthScope)
+		grpclog.Infoln("ServiceAccountCreds done")
+	case "jwt_token_creds":
+		if !*useTLS && !*useALTS {
+			grpclog.Fatalf("Neither TLS or ALTS are enabled. TLS or ALTS is required to execute jwt_token_creds test case.")
+		}
+		interop.DoJWTTokenCreds(tc, *serviceAccountKeyFile)
+		grpclog.Infoln("JWTtokenCreds done")
+	case "per_rpc_creds":
+		if !*useTLS && !*useALTS {
+			grpclog.Fatalf("Neither TLS or ALTS are enabled. TLS or ALTS is required to execute per_rpc_creds test case.")
+		}
+		interop.DoPerRPCCreds(tc, *serviceAccountKeyFile, *oauthScope)
+		grpclog.Infoln("PerRPCCreds done")
+	case "oauth2_auth_token":
+		if !*useTLS && !*useALTS {
+			grpclog.Fatalf("Neither TLS or ALTS are enabled. TLS or ALTS is required to execute oauth2_auth_token test case.")
+		}
+		interop.DoOauth2TokenCreds(tc, *serviceAccountKeyFile, *oauthScope)
+		grpclog.Infoln("Oauth2TokenCreds done")
+	case "cancel_after_begin":
+		interop.DoCancelAfterBegin(tc)
+		grpclog.Infoln("CancelAfterBegin done")
+	case "cancel_after_first_response":
+		interop.DoCancelAfterFirstResponse(tc)
+		grpclog.Infoln("CancelAfterFirstResponse done")
+	case "status_code_and_message":
+		interop.DoStatusCodeAndMessage(tc)
+		grpclog.Infoln("StatusCodeAndMessage done")
+	case "special_status_message":
+		interop.DoSpecialStatusMessage(tc)
+		grpclog.Infoln("SpecialStatusMessage done")
+	case "custom_metadata":
+		interop.DoCustomMetadata(tc)
+		grpclog.Infoln("CustomMetadata done")
+	case "unimplemented_method":
+		interop.DoUnimplementedMethod(conn)
+		grpclog.Infoln("UnimplementedMethod done")
+	case "unimplemented_service":
+		interop.DoUnimplementedService(testpb.NewUnimplementedServiceClient(conn))
+		grpclog.Infoln("UnimplementedService done")
+	default:
+		grpclog.Fatal("Unsupported test case: ", *testCase)
+	}
+}

vendor/google.golang.org/grpc/interop/grpc_testing/test.proto

@@ -0,0 +1,174 @@
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+syntax = "proto3";
+
+package grpc.testing;
+
+message Empty {}
+
+// The type of payload that should be returned.
+enum PayloadType {
+  // Compressable text format.
+  COMPRESSABLE = 0;
+
+  // Uncompressable binary format.
+  UNCOMPRESSABLE = 1;
+
+  // Randomly chosen from all other formats defined in this enum.
+  RANDOM = 2;
+}
+
+// A block of data, to simply increase gRPC message size.
+message Payload {
+  // The type of data in body.
+  PayloadType type = 1;
+  // Primary contents of payload.
+  bytes body = 2;
+}
+
+// A protobuf representation for grpc status. This is used by test
+// clients to specify a status that the server should attempt to return.
+message EchoStatus {
+  int32 code = 1;
+  string message = 2;
+}
+
+// Unary request.
+message SimpleRequest {
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, server randomly chooses one from other formats.
+  PayloadType response_type = 1;
+
+  // Desired payload size in the response from the server.
+  // If response_type is COMPRESSABLE, this denotes the size before compression.
+  int32 response_size = 2;
+
+  // Optional input payload sent along with the request.
+  Payload payload = 3;
+
+  // Whether SimpleResponse should include username.
+  bool fill_username = 4;
+
+  // Whether SimpleResponse should include OAuth scope.
+  bool fill_oauth_scope = 5;
+
+  // Whether server should return a given status
+  EchoStatus response_status = 7;
+}
+
+// Unary response, as configured by the request.
+message SimpleResponse {
+  // Payload to increase message size.
+  Payload payload = 1;
+
+  // The user the request came from, for verifying authentication was
+  // successful when the client expected it.
+  string username = 2;
+  
+  // OAuth scope.
+  string oauth_scope = 3;
+}
+
+// Client-streaming request.
+message StreamingInputCallRequest {
+  // Optional input payload sent along with the request.
+  Payload payload = 1;
+
+  // Not expecting any payload from the response.
+}
+
+// Client-streaming response.
+message StreamingInputCallResponse {
+  // Aggregated size of payloads received from the client.
+  int32 aggregated_payload_size = 1;
+}
+
+// Configuration for a particular response.
+message ResponseParameters {
+  // Desired payload sizes in responses from the server.
+  // If response_type is COMPRESSABLE, this denotes the size before compression.
+  int32 size = 1;
+
+  // Desired interval between consecutive responses in the response stream in
+  // microseconds.
+  int32 interval_us = 2;
+}
+
+// Server-streaming request.
+message StreamingOutputCallRequest {
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, the payload from each response in the stream
+  // might be of different types. This is to simulate a mixed type of payload
+  // stream.
+  PayloadType response_type = 1;
+
+  // Configuration for each expected response message.
+  repeated ResponseParameters response_parameters = 2;
+
+  // Optional input payload sent along with the request.
+  Payload payload = 3;
+
+  // Whether server should return a given status
+  EchoStatus response_status = 7;
+}
+
+// Server-streaming response, as configured by the request and parameters.
+message StreamingOutputCallResponse {
+  // Payload to increase response size.
+  Payload payload = 1;
+}
+
+// A simple service to test the various types of RPCs and experiment with
+// performance with various types of payload.
+service TestService {
+  // One empty request followed by one empty response.
+  rpc EmptyCall(Empty) returns (Empty);
+
+  // One request followed by one response.
+  // The server returns the client payload as-is.
+  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by a sequence of responses (streamed download).
+  // The server returns the payload with client desired type and sizes.
+  rpc StreamingOutputCall(StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by one response (streamed upload).
+  // The server returns the aggregated size of client payload as the result.
+  rpc StreamingInputCall(stream StreamingInputCallRequest)
+      returns (StreamingInputCallResponse);
+
+  // A sequence of requests with each request served by the server immediately.
+  // As one request could lead to multiple responses, this interface
+  // demonstrates the idea of full duplexing.
+  rpc FullDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by a sequence of responses.
+  // The server buffers all the client requests and then serves them in order. A
+  // stream of responses are returned to the client when the server starts with
+  // first request.
+  rpc HalfDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+}
+
+// A simple service NOT implemented at servers so clients can test for
+// that case.
+service UnimplementedService {
+  // A call that no server should implement
+  rpc UnimplementedCall(grpc.testing.Empty) returns (grpc.testing.Empty);
+}

vendor/google.golang.org/grpc/interop/http2/negative_http2_client.go

@@ -0,0 +1,159 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * Client used to test http2 error edge cases like GOAWAYs and RST_STREAMs
+ *
+ * Documentation:
+ *	 https://github.com/grpc/grpc/blob/master/doc/negative-http2-interop-test-descriptions.md
+ */
+
+package main
+
+import (
+	"flag"
+	"net"
+	"strconv"
+	"sync"
+	"time"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/interop"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+	"google.golang.org/grpc/status"
+)
+
+var (
+	serverHost = flag.String("server_host", "127.0.0.1", "The server host name")
+	serverPort = flag.Int("server_port", 8080, "The server port number")
+	testCase   = flag.String("test_case", "goaway",
+		`Configure different test cases. Valid options are:
+        goaway : client sends two requests, the server will send a goaway in between;
+        rst_after_header : server will send rst_stream after it sends headers;
+        rst_during_data : server will send rst_stream while sending data;
+        rst_after_data : server will send rst_stream after sending data;
+        ping : server will send pings between each http2 frame;
+        max_streams : server will ensure that the max_concurrent_streams limit is upheld;`)
+	largeReqSize  = 271828
+	largeRespSize = 314159
+)
+
+func largeSimpleRequest() *testpb.SimpleRequest {
+	pl := interop.ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	return &testpb.SimpleRequest{
+		ResponseType: testpb.PayloadType_COMPRESSABLE,
+		ResponseSize: int32(largeRespSize),
+		Payload:      pl,
+	}
+}
+
+// sends two unary calls. The server asserts that the calls use different connections.
+func goaway(tc testpb.TestServiceClient) {
+	interop.DoLargeUnaryCall(tc)
+	// sleep to ensure that the client has time to recv the GOAWAY.
+	// TODO(ncteisen): make this less hacky.
+	time.Sleep(1 * time.Second)
+	interop.DoLargeUnaryCall(tc)
+}
+
+func rstAfterHeader(tc testpb.TestServiceClient) {
+	req := largeSimpleRequest()
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if reply != nil {
+		grpclog.Fatalf("Client received reply despite server sending rst stream after header")
+	}
+	if status.Code(err) != codes.Internal {
+		grpclog.Fatalf("%v.UnaryCall() = _, %v, want _, %v", tc, status.Code(err), codes.Internal)
+	}
+}
+
+func rstDuringData(tc testpb.TestServiceClient) {
+	req := largeSimpleRequest()
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if reply != nil {
+		grpclog.Fatalf("Client received reply despite server sending rst stream during data")
+	}
+	if status.Code(err) != codes.Unknown {
+		grpclog.Fatalf("%v.UnaryCall() = _, %v, want _, %v", tc, status.Code(err), codes.Unknown)
+	}
+}
+
+func rstAfterData(tc testpb.TestServiceClient) {
+	req := largeSimpleRequest()
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if reply != nil {
+		grpclog.Fatalf("Client received reply despite server sending rst stream after data")
+	}
+	if status.Code(err) != codes.Internal {
+		grpclog.Fatalf("%v.UnaryCall() = _, %v, want _, %v", tc, status.Code(err), codes.Internal)
+	}
+}
+
+func ping(tc testpb.TestServiceClient) {
+	// The server will assert that every ping it sends was ACK-ed by the client.
+	interop.DoLargeUnaryCall(tc)
+}
+
+func maxStreams(tc testpb.TestServiceClient) {
+	interop.DoLargeUnaryCall(tc)
+	var wg sync.WaitGroup
+	for i := 0; i < 15; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			interop.DoLargeUnaryCall(tc)
+		}()
+	}
+	wg.Wait()
+}
+
+func main() {
+	flag.Parse()
+	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
+	var opts []grpc.DialOption
+	opts = append(opts, grpc.WithInsecure())
+	conn, err := grpc.Dial(serverAddr, opts...)
+	if err != nil {
+		grpclog.Fatalf("Fail to dial: %v", err)
+	}
+	defer conn.Close()
+	tc := testpb.NewTestServiceClient(conn)
+	switch *testCase {
+	case "goaway":
+		goaway(tc)
+		grpclog.Infoln("goaway done")
+	case "rst_after_header":
+		rstAfterHeader(tc)
+		grpclog.Infoln("rst_after_header done")
+	case "rst_during_data":
+		rstDuringData(tc)
+		grpclog.Infoln("rst_during_data done")
+	case "rst_after_data":
+		rstAfterData(tc)
+		grpclog.Infoln("rst_after_data done")
+	case "ping":
+		ping(tc)
+		grpclog.Infoln("ping done")
+	case "max_streams":
+		maxStreams(tc)
+		grpclog.Infoln("max_streams done")
+	default:
+		grpclog.Fatal("Unsupported test case: ", *testCase)
+	}
+}

vendor/google.golang.org/grpc/interop/server/server.go

@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2014 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package main
+
+import (
+	"flag"
+	"net"
+	"strconv"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/alts"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/interop"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+	"google.golang.org/grpc/testdata"
+)
+
+var (
+	useTLS     = flag.Bool("use_tls", false, "Connection uses TLS if true, else plain TCP")
+	useALTS    = flag.Bool("use_alts", false, "Connection uses ALTS if true (this option can only be used on GCP)")
+	altsHSAddr = flag.String("alts_handshaker_service_address", "", "ALTS handshaker gRPC service address")
+	certFile   = flag.String("tls_cert_file", "", "The TLS cert file")
+	keyFile    = flag.String("tls_key_file", "", "The TLS key file")
+	port       = flag.Int("port", 10000, "The server port")
+)
+
+func main() {
+	flag.Parse()
+	if *useTLS && *useALTS {
+		grpclog.Fatalf("use_tls and use_alts cannot be both set to true")
+	}
+	p := strconv.Itoa(*port)
+	lis, err := net.Listen("tcp", ":"+p)
+	if err != nil {
+		grpclog.Fatalf("failed to listen: %v", err)
+	}
+	var opts []grpc.ServerOption
+	if *useTLS {
+		if *certFile == "" {
+			*certFile = testdata.Path("server1.pem")
+		}
+		if *keyFile == "" {
+			*keyFile = testdata.Path("server1.key")
+		}
+		creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
+		if err != nil {
+			grpclog.Fatalf("Failed to generate credentials %v", err)
+		}
+		opts = append(opts, grpc.Creds(creds))
+	} else if *useALTS {
+		altsOpts := alts.DefaultServerOptions()
+		if *altsHSAddr != "" {
+			altsOpts.HandshakerServiceAddress = *altsHSAddr
+		}
+		altsTC := alts.NewServerCreds(altsOpts)
+		opts = append(opts, grpc.Creds(altsTC))
+	}
+	server := grpc.NewServer(opts...)
+	testpb.RegisterTestServiceServer(server, interop.NewTestServer())
+	server.Serve(lis)
+}

vendor/google.golang.org/grpc/interop/test_utils.go

@@ -0,0 +1,766 @@
+/*
+ *
+ * Copyright 2014 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+//go:generate protoc --go_out=plugins=grpc:. grpc_testing/test.proto
+
+package interop
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"strings"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"golang.org/x/net/context"
+	"golang.org/x/oauth2"
+	"golang.org/x/oauth2/google"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/grpclog"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+)
+
+var (
+	reqSizes            = []int{27182, 8, 1828, 45904}
+	respSizes           = []int{31415, 9, 2653, 58979}
+	largeReqSize        = 271828
+	largeRespSize       = 314159
+	initialMetadataKey  = "x-grpc-test-echo-initial"
+	trailingMetadataKey = "x-grpc-test-echo-trailing-bin"
+)
+
+// ClientNewPayload returns a payload of the given type and size.
+func ClientNewPayload(t testpb.PayloadType, size int) *testpb.Payload {
+	if size < 0 {
+		grpclog.Fatalf("Requested a response with invalid length %d", size)
+	}
+	body := make([]byte, size)
+	switch t {
+	case testpb.PayloadType_COMPRESSABLE:
+	case testpb.PayloadType_UNCOMPRESSABLE:
+		grpclog.Fatalf("PayloadType UNCOMPRESSABLE is not supported")
+	default:
+		grpclog.Fatalf("Unsupported payload type: %d", t)
+	}
+	return &testpb.Payload{
+		Type: t,
+		Body: body,
+	}
+}
+
+// DoEmptyUnaryCall performs a unary RPC with empty request and response messages.
+func DoEmptyUnaryCall(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	reply, err := tc.EmptyCall(context.Background(), &testpb.Empty{}, args...)
+	if err != nil {
+		grpclog.Fatal("/TestService/EmptyCall RPC failed: ", err)
+	}
+	if !proto.Equal(&testpb.Empty{}, reply) {
+		grpclog.Fatalf("/TestService/EmptyCall receives %v, want %v", reply, testpb.Empty{})
+	}
+}
+
+// DoLargeUnaryCall performs a unary RPC with large payload in the request and response.
+func DoLargeUnaryCall(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	req := &testpb.SimpleRequest{
+		ResponseType: testpb.PayloadType_COMPRESSABLE,
+		ResponseSize: int32(largeRespSize),
+		Payload:      pl,
+	}
+	reply, err := tc.UnaryCall(context.Background(), req, args...)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	t := reply.GetPayload().GetType()
+	s := len(reply.GetPayload().GetBody())
+	if t != testpb.PayloadType_COMPRESSABLE || s != largeRespSize {
+		grpclog.Fatalf("Got the reply with type %d len %d; want %d, %d", t, s, testpb.PayloadType_COMPRESSABLE, largeRespSize)
+	}
+}
+
+// DoClientStreaming performs a client streaming RPC.
+func DoClientStreaming(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	stream, err := tc.StreamingInputCall(context.Background(), args...)
+	if err != nil {
+		grpclog.Fatalf("%v.StreamingInputCall(_) = _, %v", tc, err)
+	}
+	var sum int
+	for _, s := range reqSizes {
+		pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, s)
+		req := &testpb.StreamingInputCallRequest{
+			Payload: pl,
+		}
+		if err := stream.Send(req); err != nil {
+			grpclog.Fatalf("%v has error %v while sending %v", stream, err, req)
+		}
+		sum += s
+	}
+	reply, err := stream.CloseAndRecv()
+	if err != nil {
+		grpclog.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
+	}
+	if reply.GetAggregatedPayloadSize() != int32(sum) {
+		grpclog.Fatalf("%v.CloseAndRecv().GetAggregatePayloadSize() = %v; want %v", stream, reply.GetAggregatedPayloadSize(), sum)
+	}
+}
+
+// DoServerStreaming performs a server streaming RPC.
+func DoServerStreaming(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	respParam := make([]*testpb.ResponseParameters, len(respSizes))
+	for i, s := range respSizes {
+		respParam[i] = &testpb.ResponseParameters{
+			Size: int32(s),
+		}
+	}
+	req := &testpb.StreamingOutputCallRequest{
+		ResponseType:       testpb.PayloadType_COMPRESSABLE,
+		ResponseParameters: respParam,
+	}
+	stream, err := tc.StreamingOutputCall(context.Background(), req, args...)
+	if err != nil {
+		grpclog.Fatalf("%v.StreamingOutputCall(_) = _, %v", tc, err)
+	}
+	var rpcStatus error
+	var respCnt int
+	var index int
+	for {
+		reply, err := stream.Recv()
+		if err != nil {
+			rpcStatus = err
+			break
+		}
+		t := reply.GetPayload().GetType()
+		if t != testpb.PayloadType_COMPRESSABLE {
+			grpclog.Fatalf("Got the reply of type %d, want %d", t, testpb.PayloadType_COMPRESSABLE)
+		}
+		size := len(reply.GetPayload().GetBody())
+		if size != respSizes[index] {
+			grpclog.Fatalf("Got reply body of length %d, want %d", size, respSizes[index])
+		}
+		index++
+		respCnt++
+	}
+	if rpcStatus != io.EOF {
+		grpclog.Fatalf("Failed to finish the server streaming rpc: %v", rpcStatus)
+	}
+	if respCnt != len(respSizes) {
+		grpclog.Fatalf("Got %d reply, want %d", len(respSizes), respCnt)
+	}
+}
+
+// DoPingPong performs ping-pong style bi-directional streaming RPC.
+func DoPingPong(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	stream, err := tc.FullDuplexCall(context.Background(), args...)
+	if err != nil {
+		grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v", tc, err)
+	}
+	var index int
+	for index < len(reqSizes) {
+		respParam := []*testpb.ResponseParameters{
+			{
+				Size: int32(respSizes[index]),
+			},
+		}
+		pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, reqSizes[index])
+		req := &testpb.StreamingOutputCallRequest{
+			ResponseType:       testpb.PayloadType_COMPRESSABLE,
+			ResponseParameters: respParam,
+			Payload:            pl,
+		}
+		if err := stream.Send(req); err != nil {
+			grpclog.Fatalf("%v has error %v while sending %v", stream, err, req)
+		}
+		reply, err := stream.Recv()
+		if err != nil {
+			grpclog.Fatalf("%v.Recv() = %v", stream, err)
+		}
+		t := reply.GetPayload().GetType()
+		if t != testpb.PayloadType_COMPRESSABLE {
+			grpclog.Fatalf("Got the reply of type %d, want %d", t, testpb.PayloadType_COMPRESSABLE)
+		}
+		size := len(reply.GetPayload().GetBody())
+		if size != respSizes[index] {
+			grpclog.Fatalf("Got reply body of length %d, want %d", size, respSizes[index])
+		}
+		index++
+	}
+	if err := stream.CloseSend(); err != nil {
+		grpclog.Fatalf("%v.CloseSend() got %v, want %v", stream, err, nil)
+	}
+	if _, err := stream.Recv(); err != io.EOF {
+		grpclog.Fatalf("%v failed to complele the ping pong test: %v", stream, err)
+	}
+}
+
+// DoEmptyStream sets up a bi-directional streaming with zero message.
+func DoEmptyStream(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	stream, err := tc.FullDuplexCall(context.Background(), args...)
+	if err != nil {
+		grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v", tc, err)
+	}
+	if err := stream.CloseSend(); err != nil {
+		grpclog.Fatalf("%v.CloseSend() got %v, want %v", stream, err, nil)
+	}
+	if _, err := stream.Recv(); err != io.EOF {
+		grpclog.Fatalf("%v failed to complete the empty stream test: %v", stream, err)
+	}
+}
+
+// DoTimeoutOnSleepingServer performs an RPC on a sleep server which causes RPC timeout.
+func DoTimeoutOnSleepingServer(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
+	defer cancel()
+	stream, err := tc.FullDuplexCall(ctx, args...)
+	if err != nil {
+		if status.Code(err) == codes.DeadlineExceeded {
+			return
+		}
+		grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v", tc, err)
+	}
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, 27182)
+	req := &testpb.StreamingOutputCallRequest{
+		ResponseType: testpb.PayloadType_COMPRESSABLE,
+		Payload:      pl,
+	}
+	if err := stream.Send(req); err != nil && err != io.EOF {
+		grpclog.Fatalf("%v.Send(_) = %v", stream, err)
+	}
+	if _, err := stream.Recv(); status.Code(err) != codes.DeadlineExceeded {
+		grpclog.Fatalf("%v.Recv() = _, %v, want error code %d", stream, err, codes.DeadlineExceeded)
+	}
+}
+
+// DoComputeEngineCreds performs a unary RPC with compute engine auth.
+func DoComputeEngineCreds(tc testpb.TestServiceClient, serviceAccount, oauthScope string) {
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	req := &testpb.SimpleRequest{
+		ResponseType:   testpb.PayloadType_COMPRESSABLE,
+		ResponseSize:   int32(largeRespSize),
+		Payload:        pl,
+		FillUsername:   true,
+		FillOauthScope: true,
+	}
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	user := reply.GetUsername()
+	scope := reply.GetOauthScope()
+	if user != serviceAccount {
+		grpclog.Fatalf("Got user name %q, want %q.", user, serviceAccount)
+	}
+	if !strings.Contains(oauthScope, scope) {
+		grpclog.Fatalf("Got OAuth scope %q which is NOT a substring of %q.", scope, oauthScope)
+	}
+}
+
+func getServiceAccountJSONKey(keyFile string) []byte {
+	jsonKey, err := ioutil.ReadFile(keyFile)
+	if err != nil {
+		grpclog.Fatalf("Failed to read the service account key file: %v", err)
+	}
+	return jsonKey
+}
+
+// DoServiceAccountCreds performs a unary RPC with service account auth.
+func DoServiceAccountCreds(tc testpb.TestServiceClient, serviceAccountKeyFile, oauthScope string) {
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	req := &testpb.SimpleRequest{
+		ResponseType:   testpb.PayloadType_COMPRESSABLE,
+		ResponseSize:   int32(largeRespSize),
+		Payload:        pl,
+		FillUsername:   true,
+		FillOauthScope: true,
+	}
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	jsonKey := getServiceAccountJSONKey(serviceAccountKeyFile)
+	user := reply.GetUsername()
+	scope := reply.GetOauthScope()
+	if !strings.Contains(string(jsonKey), user) {
+		grpclog.Fatalf("Got user name %q which is NOT a substring of %q.", user, jsonKey)
+	}
+	if !strings.Contains(oauthScope, scope) {
+		grpclog.Fatalf("Got OAuth scope %q which is NOT a substring of %q.", scope, oauthScope)
+	}
+}
+
+// DoJWTTokenCreds performs a unary RPC with JWT token auth.
+func DoJWTTokenCreds(tc testpb.TestServiceClient, serviceAccountKeyFile string) {
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	req := &testpb.SimpleRequest{
+		ResponseType: testpb.PayloadType_COMPRESSABLE,
+		ResponseSize: int32(largeRespSize),
+		Payload:      pl,
+		FillUsername: true,
+	}
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	jsonKey := getServiceAccountJSONKey(serviceAccountKeyFile)
+	user := reply.GetUsername()
+	if !strings.Contains(string(jsonKey), user) {
+		grpclog.Fatalf("Got user name %q which is NOT a substring of %q.", user, jsonKey)
+	}
+}
+
+// GetToken obtains an OAUTH token from the input.
+func GetToken(serviceAccountKeyFile string, oauthScope string) *oauth2.Token {
+	jsonKey := getServiceAccountJSONKey(serviceAccountKeyFile)
+	config, err := google.JWTConfigFromJSON(jsonKey, oauthScope)
+	if err != nil {
+		grpclog.Fatalf("Failed to get the config: %v", err)
+	}
+	token, err := config.TokenSource(context.Background()).Token()
+	if err != nil {
+		grpclog.Fatalf("Failed to get the token: %v", err)
+	}
+	return token
+}
+
+// DoOauth2TokenCreds performs a unary RPC with OAUTH2 token auth.
+func DoOauth2TokenCreds(tc testpb.TestServiceClient, serviceAccountKeyFile, oauthScope string) {
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	req := &testpb.SimpleRequest{
+		ResponseType:   testpb.PayloadType_COMPRESSABLE,
+		ResponseSize:   int32(largeRespSize),
+		Payload:        pl,
+		FillUsername:   true,
+		FillOauthScope: true,
+	}
+	reply, err := tc.UnaryCall(context.Background(), req)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	jsonKey := getServiceAccountJSONKey(serviceAccountKeyFile)
+	user := reply.GetUsername()
+	scope := reply.GetOauthScope()
+	if !strings.Contains(string(jsonKey), user) {
+		grpclog.Fatalf("Got user name %q which is NOT a substring of %q.", user, jsonKey)
+	}
+	if !strings.Contains(oauthScope, scope) {
+		grpclog.Fatalf("Got OAuth scope %q which is NOT a substring of %q.", scope, oauthScope)
+	}
+}
+
+// DoPerRPCCreds performs a unary RPC with per RPC OAUTH2 token.
+func DoPerRPCCreds(tc testpb.TestServiceClient, serviceAccountKeyFile, oauthScope string) {
+	jsonKey := getServiceAccountJSONKey(serviceAccountKeyFile)
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
+	req := &testpb.SimpleRequest{
+		ResponseType:   testpb.PayloadType_COMPRESSABLE,
+		ResponseSize:   int32(largeRespSize),
+		Payload:        pl,
+		FillUsername:   true,
+		FillOauthScope: true,
+	}
+	token := GetToken(serviceAccountKeyFile, oauthScope)
+	kv := map[string]string{"authorization": token.Type() + " " + token.AccessToken}
+	ctx := metadata.NewOutgoingContext(context.Background(), metadata.MD{"authorization": []string{kv["authorization"]}})
+	reply, err := tc.UnaryCall(ctx, req)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	user := reply.GetUsername()
+	scope := reply.GetOauthScope()
+	if !strings.Contains(string(jsonKey), user) {
+		grpclog.Fatalf("Got user name %q which is NOT a substring of %q.", user, jsonKey)
+	}
+	if !strings.Contains(oauthScope, scope) {
+		grpclog.Fatalf("Got OAuth scope %q which is NOT a substring of %q.", scope, oauthScope)
+	}
+}
+
+var testMetadata = metadata.MD{
+	"key1": []string{"value1"},
+	"key2": []string{"value2"},
+}
+
+// DoCancelAfterBegin cancels the RPC after metadata has been sent but before payloads are sent.
+func DoCancelAfterBegin(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	ctx, cancel := context.WithCancel(metadata.NewOutgoingContext(context.Background(), testMetadata))
+	stream, err := tc.StreamingInputCall(ctx, args...)
+	if err != nil {
+		grpclog.Fatalf("%v.StreamingInputCall(_) = _, %v", tc, err)
+	}
+	cancel()
+	_, err = stream.CloseAndRecv()
+	if status.Code(err) != codes.Canceled {
+		grpclog.Fatalf("%v.CloseAndRecv() got error code %d, want %d", stream, status.Code(err), codes.Canceled)
+	}
+}
+
+// DoCancelAfterFirstResponse cancels the RPC after receiving the first message from the server.
+func DoCancelAfterFirstResponse(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	ctx, cancel := context.WithCancel(context.Background())
+	stream, err := tc.FullDuplexCall(ctx, args...)
+	if err != nil {
+		grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v", tc, err)
+	}
+	respParam := []*testpb.ResponseParameters{
+		{
+			Size: 31415,
+		},
+	}
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, 27182)
+	req := &testpb.StreamingOutputCallRequest{
+		ResponseType:       testpb.PayloadType_COMPRESSABLE,
+		ResponseParameters: respParam,
+		Payload:            pl,
+	}
+	if err := stream.Send(req); err != nil {
+		grpclog.Fatalf("%v has error %v while sending %v", stream, err, req)
+	}
+	if _, err := stream.Recv(); err != nil {
+		grpclog.Fatalf("%v.Recv() = %v", stream, err)
+	}
+	cancel()
+	if _, err := stream.Recv(); status.Code(err) != codes.Canceled {
+		grpclog.Fatalf("%v compleled with error code %d, want %d", stream, status.Code(err), codes.Canceled)
+	}
+}
+
+var (
+	initialMetadataValue  = "test_initial_metadata_value"
+	trailingMetadataValue = "\x0a\x0b\x0a\x0b\x0a\x0b"
+	customMetadata        = metadata.Pairs(
+		initialMetadataKey, initialMetadataValue,
+		trailingMetadataKey, trailingMetadataValue,
+	)
+)
+
+func validateMetadata(header, trailer metadata.MD) {
+	if len(header[initialMetadataKey]) != 1 {
+		grpclog.Fatalf("Expected exactly one header from server. Received %d", len(header[initialMetadataKey]))
+	}
+	if header[initialMetadataKey][0] != initialMetadataValue {
+		grpclog.Fatalf("Got header %s; want %s", header[initialMetadataKey][0], initialMetadataValue)
+	}
+	if len(trailer[trailingMetadataKey]) != 1 {
+		grpclog.Fatalf("Expected exactly one trailer from server. Received %d", len(trailer[trailingMetadataKey]))
+	}
+	if trailer[trailingMetadataKey][0] != trailingMetadataValue {
+		grpclog.Fatalf("Got trailer %s; want %s", trailer[trailingMetadataKey][0], trailingMetadataValue)
+	}
+}
+
+// DoCustomMetadata checks that metadata is echoed back to the client.
+func DoCustomMetadata(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	// Testing with UnaryCall.
+	pl := ClientNewPayload(testpb.PayloadType_COMPRESSABLE, 1)
+	req := &testpb.SimpleRequest{
+		ResponseType: testpb.PayloadType_COMPRESSABLE,
+		ResponseSize: int32(1),
+		Payload:      pl,
+	}
+	ctx := metadata.NewOutgoingContext(context.Background(), customMetadata)
+	var header, trailer metadata.MD
+	args = append(args, grpc.Header(&header), grpc.Trailer(&trailer))
+	reply, err := tc.UnaryCall(
+		ctx,
+		req,
+		args...,
+	)
+	if err != nil {
+		grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
+	}
+	t := reply.GetPayload().GetType()
+	s := len(reply.GetPayload().GetBody())
+	if t != testpb.PayloadType_COMPRESSABLE || s != 1 {
+		grpclog.Fatalf("Got the reply with type %d len %d; want %d, %d", t, s, testpb.PayloadType_COMPRESSABLE, 1)
+	}
+	validateMetadata(header, trailer)
+
+	// Testing with FullDuplex.
+	stream, err := tc.FullDuplexCall(ctx, args...)
+	if err != nil {
+		grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v, want <nil>", tc, err)
+	}
+	respParam := []*testpb.ResponseParameters{
+		{
+			Size: 1,
+		},
+	}
+	streamReq := &testpb.StreamingOutputCallRequest{
+		ResponseType:       testpb.PayloadType_COMPRESSABLE,
+		ResponseParameters: respParam,
+		Payload:            pl,
+	}
+	if err := stream.Send(streamReq); err != nil {
+		grpclog.Fatalf("%v has error %v while sending %v", stream, err, streamReq)
+	}
+	streamHeader, err := stream.Header()
+	if err != nil {
+		grpclog.Fatalf("%v.Header() = %v", stream, err)
+	}
+	if _, err := stream.Recv(); err != nil {
+		grpclog.Fatalf("%v.Recv() = %v", stream, err)
+	}
+	if err := stream.CloseSend(); err != nil {
+		grpclog.Fatalf("%v.CloseSend() = %v, want <nil>", stream, err)
+	}
+	if _, err := stream.Recv(); err != io.EOF {
+		grpclog.Fatalf("%v failed to complete the custom metadata test: %v", stream, err)
+	}
+	streamTrailer := stream.Trailer()
+	validateMetadata(streamHeader, streamTrailer)
+}
+
+// DoStatusCodeAndMessage checks that the status code is propagated back to the client.
+func DoStatusCodeAndMessage(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	var code int32 = 2
+	msg := "test status message"
+	expectedErr := status.Error(codes.Code(code), msg)
+	respStatus := &testpb.EchoStatus{
+		Code:    code,
+		Message: msg,
+	}
+	// Test UnaryCall.
+	req := &testpb.SimpleRequest{
+		ResponseStatus: respStatus,
+	}
+	if _, err := tc.UnaryCall(context.Background(), req, args...); err == nil || err.Error() != expectedErr.Error() {
+		grpclog.Fatalf("%v.UnaryCall(_, %v) = _, %v, want _, %v", tc, req, err, expectedErr)
+	}
+	// Test FullDuplexCall.
+	stream, err := tc.FullDuplexCall(context.Background(), args...)
+	if err != nil {
+		grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v, want <nil>", tc, err)
+	}
+	streamReq := &testpb.StreamingOutputCallRequest{
+		ResponseStatus: respStatus,
+	}
+	if err := stream.Send(streamReq); err != nil {
+		grpclog.Fatalf("%v has error %v while sending %v, want <nil>", stream, err, streamReq)
+	}
+	if err := stream.CloseSend(); err != nil {
+		grpclog.Fatalf("%v.CloseSend() = %v, want <nil>", stream, err)
+	}
+	if _, err = stream.Recv(); err.Error() != expectedErr.Error() {
+		grpclog.Fatalf("%v.Recv() returned error %v, want %v", stream, err, expectedErr)
+	}
+}
+
+// DoSpecialStatusMessage verifies Unicode and whitespace is correctly processed
+// in status message.
+func DoSpecialStatusMessage(tc testpb.TestServiceClient, args ...grpc.CallOption) {
+	const (
+		code int32  = 2
+		msg  string = "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n"
+	)
+	expectedErr := status.Error(codes.Code(code), msg)
+	req := &testpb.SimpleRequest{
+		ResponseStatus: &testpb.EchoStatus{
+			Code:    code,
+			Message: msg,
+		},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if _, err := tc.UnaryCall(ctx, req, args...); err == nil || err.Error() != expectedErr.Error() {
+		grpclog.Fatalf("%v.UnaryCall(_, %v) = _, %v, want _, %v", tc, req, err, expectedErr)
+	}
+}
+
+// DoUnimplementedService attempts to call a method from an unimplemented service.
+func DoUnimplementedService(tc testpb.UnimplementedServiceClient) {
+	_, err := tc.UnimplementedCall(context.Background(), &testpb.Empty{})
+	if status.Code(err) != codes.Unimplemented {
+		grpclog.Fatalf("%v.UnimplementedCall() = _, %v, want _, %v", tc, status.Code(err), codes.Unimplemented)
+	}
+}
+
+// DoUnimplementedMethod attempts to call an unimplemented method.
+func DoUnimplementedMethod(cc *grpc.ClientConn) {
+	var req, reply proto.Message
+	if err := cc.Invoke(context.Background(), "/grpc.testing.TestService/UnimplementedCall", req, reply); err == nil || status.Code(err) != codes.Unimplemented {
+		grpclog.Fatalf("ClientConn.Invoke(_, _, _, _, _) = %v, want error code %s", err, codes.Unimplemented)
+	}
+}
+
+type testServer struct {
+}
+
+// NewTestServer creates a test server for test service.
+func NewTestServer() testpb.TestServiceServer {
+	return &testServer{}
+}
+
+func (s *testServer) EmptyCall(ctx context.Context, in *testpb.Empty) (*testpb.Empty, error) {
+	return new(testpb.Empty), nil
+}
+
+func serverNewPayload(t testpb.PayloadType, size int32) (*testpb.Payload, error) {
+	if size < 0 {
+		return nil, fmt.Errorf("requested a response with invalid length %d", size)
+	}
+	body := make([]byte, size)
+	switch t {
+	case testpb.PayloadType_COMPRESSABLE:
+	case testpb.PayloadType_UNCOMPRESSABLE:
+		return nil, fmt.Errorf("payloadType UNCOMPRESSABLE is not supported")
+	default:
+		return nil, fmt.Errorf("unsupported payload type: %d", t)
+	}
+	return &testpb.Payload{
+		Type: t,
+		Body: body,
+	}, nil
+}
+
+func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
+	st := in.GetResponseStatus()
+	if md, ok := metadata.FromIncomingContext(ctx); ok {
+		if initialMetadata, ok := md[initialMetadataKey]; ok {
+			header := metadata.Pairs(initialMetadataKey, initialMetadata[0])
+			grpc.SendHeader(ctx, header)
+		}
+		if trailingMetadata, ok := md[trailingMetadataKey]; ok {
+			trailer := metadata.Pairs(trailingMetadataKey, trailingMetadata[0])
+			grpc.SetTrailer(ctx, trailer)
+		}
+	}
+	if st != nil && st.Code != 0 {
+		return nil, status.Error(codes.Code(st.Code), st.Message)
+	}
+	pl, err := serverNewPayload(in.GetResponseType(), in.GetResponseSize())
+	if err != nil {
+		return nil, err
+	}
+	return &testpb.SimpleResponse{
+		Payload: pl,
+	}, nil
+}
+
+func (s *testServer) StreamingOutputCall(args *testpb.StreamingOutputCallRequest, stream testpb.TestService_StreamingOutputCallServer) error {
+	cs := args.GetResponseParameters()
+	for _, c := range cs {
+		if us := c.GetIntervalUs(); us > 0 {
+			time.Sleep(time.Duration(us) * time.Microsecond)
+		}
+		pl, err := serverNewPayload(args.GetResponseType(), c.GetSize())
+		if err != nil {
+			return err
+		}
+		if err := stream.Send(&testpb.StreamingOutputCallResponse{
+			Payload: pl,
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *testServer) StreamingInputCall(stream testpb.TestService_StreamingInputCallServer) error {
+	var sum int
+	for {
+		in, err := stream.Recv()
+		if err == io.EOF {
+			return stream.SendAndClose(&testpb.StreamingInputCallResponse{
+				AggregatedPayloadSize: int32(sum),
+			})
+		}
+		if err != nil {
+			return err
+		}
+		p := in.GetPayload().GetBody()
+		sum += len(p)
+	}
+}
+
+func (s *testServer) FullDuplexCall(stream testpb.TestService_FullDuplexCallServer) error {
+	if md, ok := metadata.FromIncomingContext(stream.Context()); ok {
+		if initialMetadata, ok := md[initialMetadataKey]; ok {
+			header := metadata.Pairs(initialMetadataKey, initialMetadata[0])
+			stream.SendHeader(header)
+		}
+		if trailingMetadata, ok := md[trailingMetadataKey]; ok {
+			trailer := metadata.Pairs(trailingMetadataKey, trailingMetadata[0])
+			stream.SetTrailer(trailer)
+		}
+	}
+	for {
+		in, err := stream.Recv()
+		if err == io.EOF {
+			// read done.
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		st := in.GetResponseStatus()
+		if st != nil && st.Code != 0 {
+			return status.Error(codes.Code(st.Code), st.Message)
+		}
+		cs := in.GetResponseParameters()
+		for _, c := range cs {
+			if us := c.GetIntervalUs(); us > 0 {
+				time.Sleep(time.Duration(us) * time.Microsecond)
+			}
+			pl, err := serverNewPayload(in.GetResponseType(), c.GetSize())
+			if err != nil {
+				return err
+			}
+			if err := stream.Send(&testpb.StreamingOutputCallResponse{
+				Payload: pl,
+			}); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (s *testServer) HalfDuplexCall(stream testpb.TestService_HalfDuplexCallServer) error {
+	var msgBuf []*testpb.StreamingOutputCallRequest
+	for {
+		in, err := stream.Recv()
+		if err == io.EOF {
+			// read done.
+			break
+		}
+		if err != nil {
+			return err
+		}
+		msgBuf = append(msgBuf, in)
+	}
+	for _, m := range msgBuf {
+		cs := m.GetResponseParameters()
+		for _, c := range cs {
+			if us := c.GetIntervalUs(); us > 0 {
+				time.Sleep(time.Duration(us) * time.Microsecond)
+			}
+			pl, err := serverNewPayload(m.GetResponseType(), c.GetSize())
+			if err != nil {
+				return err
+			}
+			if err := stream.Send(&testpb.StreamingOutputCallResponse{
+				Payload: pl,
+			}); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}