vendor/google.golang.org/grpc/test/grpc_testing/test.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: grpc_testing/test.proto
   3
   4 /*
   5 Package grpc_testing is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         grpc_testing/test.proto
   9
  10 It has these top-level messages:
  11         Empty
  12         Payload
  13         SimpleRequest
  14         SimpleResponse
  15         StreamingInputCallRequest
  16         StreamingInputCallResponse
  17         ResponseParameters
  18         StreamingOutputCallRequest
  19         StreamingOutputCallResponse
  20 */
  21 package grpc_testing
  22
  23 import proto "github.com/golang/protobuf/proto"
  24 import fmt "fmt"
  25 import math "math"
  26
  27 import (
  28         context "golang.org/x/net/context"
  29         grpc "google.golang.org/grpc"
  30 )
  31
  32 // Reference imports to suppress errors if they are not otherwise used.
  33 var _ = proto.Marshal
  34 var _ = fmt.Errorf
  35 var _ = math.Inf
  36
  37 // This is a compile-time assertion to ensure that this generated file
  38 // is compatible with the proto package it is being compiled against.
  39 // A compilation error at this line likely means your copy of the
  40 // proto package needs to be updated.
  41 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  42
  43 // The type of payload that should be returned.
  44 type PayloadType int32
  45
  46 const (
  47         // Compressable text format.
  48         PayloadType_COMPRESSABLE PayloadType = 0
  49         // Uncompressable binary format.
  50         PayloadType_UNCOMPRESSABLE PayloadType = 1
  51         // Randomly chosen from all other formats defined in this enum.
  52         PayloadType_RANDOM PayloadType = 2
  53 )
  54
  55 var PayloadType_name = map[int32]string{
  56         0: "COMPRESSABLE",
  57         1: "UNCOMPRESSABLE",
  58         2: "RANDOM",
  59 }
  60 var PayloadType_value = map[string]int32{
  61         "COMPRESSABLE":   0,
  62         "UNCOMPRESSABLE": 1,
  63         "RANDOM":         2,
  64 }
  65
  66 func (x PayloadType) String() string {
  67         return proto.EnumName(PayloadType_name, int32(x))
  68 }
  69 func (PayloadType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  70
  71 type Empty struct {
  72 }
  73
  74 func (m *Empty) Reset()                    { *m = Empty{} }
  75 func (m *Empty) String() string            { return proto.CompactTextString(m) }
  76 func (*Empty) ProtoMessage()               {}
  77 func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  78
  79 // A block of data, to simply increase gRPC message size.
  80 type Payload struct {
  81         // The type of data in body.
  82         Type PayloadType `protobuf:"varint,1,opt,name=type,enum=grpc.testing.PayloadType" json:"type,omitempty"`
  83         // Primary contents of payload.
  84         Body []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
  85 }
  86
  87 func (m *Payload) Reset()                    { *m = Payload{} }
  88 func (m *Payload) String() string            { return proto.CompactTextString(m) }
  89 func (*Payload) ProtoMessage()               {}
  90 func (*Payload) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
  91
  92 func (m *Payload) GetType() PayloadType {
  93         if m != nil {
  94                 return m.Type
  95         }
  96         return PayloadType_COMPRESSABLE
  97 }
  98
  99 func (m *Payload) GetBody() []byte {
 100         if m != nil {
 101                 return m.Body
 102         }
 103         return nil
 104 }
 105
 106 // Unary request.
 107 type SimpleRequest struct {
 108         // Desired payload type in the response from the server.
 109         // If response_type is RANDOM, server randomly chooses one from other formats.
 110         ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,json=responseType,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
 111         // Desired payload size in the response from the server.
 112         // If response_type is COMPRESSABLE, this denotes the size before compression.
 113         ResponseSize int32 `protobuf:"varint,2,opt,name=response_size,json=responseSize" json:"response_size,omitempty"`
 114         // Optional input payload sent along with the request.
 115         Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
 116         // Whether SimpleResponse should include username.
 117         FillUsername bool `protobuf:"varint,4,opt,name=fill_username,json=fillUsername" json:"fill_username,omitempty"`
 118         // Whether SimpleResponse should include OAuth scope.
 119         FillOauthScope bool `protobuf:"varint,5,opt,name=fill_oauth_scope,json=fillOauthScope" json:"fill_oauth_scope,omitempty"`
 120 }
 121
 122 func (m *SimpleRequest) Reset()                    { *m = SimpleRequest{} }
 123 func (m *SimpleRequest) String() string            { return proto.CompactTextString(m) }
 124 func (*SimpleRequest) ProtoMessage()               {}
 125 func (*SimpleRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 126
 127 func (m *SimpleRequest) GetResponseType() PayloadType {
 128         if m != nil {
 129                 return m.ResponseType
 130         }
 131         return PayloadType_COMPRESSABLE
 132 }
 133
 134 func (m *SimpleRequest) GetResponseSize() int32 {
 135         if m != nil {
 136                 return m.ResponseSize
 137         }
 138         return 0
 139 }
 140
 141 func (m *SimpleRequest) GetPayload() *Payload {
 142         if m != nil {
 143                 return m.Payload
 144         }
 145         return nil
 146 }
 147
 148 func (m *SimpleRequest) GetFillUsername() bool {
 149         if m != nil {
 150                 return m.FillUsername
 151         }
 152         return false
 153 }
 154
 155 func (m *SimpleRequest) GetFillOauthScope() bool {
 156         if m != nil {
 157                 return m.FillOauthScope
 158         }
 159         return false
 160 }
 161
 162 // Unary response, as configured by the request.
 163 type SimpleResponse struct {
 164         // Payload to increase message size.
 165         Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
 166         // The user the request came from, for verifying authentication was
 167         // successful when the client expected it.
 168         Username string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"`
 169         // OAuth scope.
 170         OauthScope string `protobuf:"bytes,3,opt,name=oauth_scope,json=oauthScope" json:"oauth_scope,omitempty"`
 171 }
 172
 173 func (m *SimpleResponse) Reset()                    { *m = SimpleResponse{} }
 174 func (m *SimpleResponse) String() string            { return proto.CompactTextString(m) }
 175 func (*SimpleResponse) ProtoMessage()               {}
 176 func (*SimpleResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 177
 178 func (m *SimpleResponse) GetPayload() *Payload {
 179         if m != nil {
 180                 return m.Payload
 181         }
 182         return nil
 183 }
 184
 185 func (m *SimpleResponse) GetUsername() string {
 186         if m != nil {
 187                 return m.Username
 188         }
 189         return ""
 190 }
 191
 192 func (m *SimpleResponse) GetOauthScope() string {
 193         if m != nil {
 194                 return m.OauthScope
 195         }
 196         return ""
 197 }
 198
 199 // Client-streaming request.
 200 type StreamingInputCallRequest struct {
 201         // Optional input payload sent along with the request.
 202         Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
 203 }
 204
 205 func (m *StreamingInputCallRequest) Reset()                    { *m = StreamingInputCallRequest{} }
 206 func (m *StreamingInputCallRequest) String() string            { return proto.CompactTextString(m) }
 207 func (*StreamingInputCallRequest) ProtoMessage()               {}
 208 func (*StreamingInputCallRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 209
 210 func (m *StreamingInputCallRequest) GetPayload() *Payload {
 211         if m != nil {
 212                 return m.Payload
 213         }
 214         return nil
 215 }
 216
 217 // Client-streaming response.
 218 type StreamingInputCallResponse struct {
 219         // Aggregated size of payloads received from the client.
 220         AggregatedPayloadSize int32 `protobuf:"varint,1,opt,name=aggregated_payload_size,json=aggregatedPayloadSize" json:"aggregated_payload_size,omitempty"`
 221 }
 222
 223 func (m *StreamingInputCallResponse) Reset()                    { *m = StreamingInputCallResponse{} }
 224 func (m *StreamingInputCallResponse) String() string            { return proto.CompactTextString(m) }
 225 func (*StreamingInputCallResponse) ProtoMessage()               {}
 226 func (*StreamingInputCallResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 227
 228 func (m *StreamingInputCallResponse) GetAggregatedPayloadSize() int32 {
 229         if m != nil {
 230                 return m.AggregatedPayloadSize
 231         }
 232         return 0
 233 }
 234
 235 // Configuration for a particular response.
 236 type ResponseParameters struct {
 237         // Desired payload sizes in responses from the server.
 238         // If response_type is COMPRESSABLE, this denotes the size before compression.
 239         Size int32 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
 240         // Desired interval between consecutive responses in the response stream in
 241         // microseconds.
 242         IntervalUs int32 `protobuf:"varint,2,opt,name=interval_us,json=intervalUs" json:"interval_us,omitempty"`
 243 }
 244
 245 func (m *ResponseParameters) Reset()                    { *m = ResponseParameters{} }
 246 func (m *ResponseParameters) String() string            { return proto.CompactTextString(m) }
 247 func (*ResponseParameters) ProtoMessage()               {}
 248 func (*ResponseParameters) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 249
 250 func (m *ResponseParameters) GetSize() int32 {
 251         if m != nil {
 252                 return m.Size
 253         }
 254         return 0
 255 }
 256
 257 func (m *ResponseParameters) GetIntervalUs() int32 {
 258         if m != nil {
 259                 return m.IntervalUs
 260         }
 261         return 0
 262 }
 263
 264 // Server-streaming request.
 265 type StreamingOutputCallRequest struct {
 266         // Desired payload type in the response from the server.
 267         // If response_type is RANDOM, the payload from each response in the stream
 268         // might be of different types. This is to simulate a mixed type of payload
 269         // stream.
 270         ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,json=responseType,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
 271         // Configuration for each expected response message.
 272         ResponseParameters []*ResponseParameters `protobuf:"bytes,2,rep,name=response_parameters,json=responseParameters" json:"response_parameters,omitempty"`
 273         // Optional input payload sent along with the request.
 274         Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
 275 }
 276
 277 func (m *StreamingOutputCallRequest) Reset()                    { *m = StreamingOutputCallRequest{} }
 278 func (m *StreamingOutputCallRequest) String() string            { return proto.CompactTextString(m) }
 279 func (*StreamingOutputCallRequest) ProtoMessage()               {}
 280 func (*StreamingOutputCallRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 281
 282 func (m *StreamingOutputCallRequest) GetResponseType() PayloadType {
 283         if m != nil {
 284                 return m.ResponseType
 285         }
 286         return PayloadType_COMPRESSABLE
 287 }
 288
 289 func (m *StreamingOutputCallRequest) GetResponseParameters() []*ResponseParameters {
 290         if m != nil {
 291                 return m.ResponseParameters
 292         }
 293         return nil
 294 }
 295
 296 func (m *StreamingOutputCallRequest) GetPayload() *Payload {
 297         if m != nil {
 298                 return m.Payload
 299         }
 300         return nil
 301 }
 302
 303 // Server-streaming response, as configured by the request and parameters.
 304 type StreamingOutputCallResponse struct {
 305         // Payload to increase response size.
 306         Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
 307 }
 308
 309 func (m *StreamingOutputCallResponse) Reset()                    { *m = StreamingOutputCallResponse{} }
 310 func (m *StreamingOutputCallResponse) String() string            { return proto.CompactTextString(m) }
 311 func (*StreamingOutputCallResponse) ProtoMessage()               {}
 312 func (*StreamingOutputCallResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 313
 314 func (m *StreamingOutputCallResponse) GetPayload() *Payload {
 315         if m != nil {
 316                 return m.Payload
 317         }
 318         return nil
 319 }
 320
 321 func init() {
 322         proto.RegisterType((*Empty)(nil), "grpc.testing.Empty")
 323         proto.RegisterType((*Payload)(nil), "grpc.testing.Payload")
 324         proto.RegisterType((*SimpleRequest)(nil), "grpc.testing.SimpleRequest")
 325         proto.RegisterType((*SimpleResponse)(nil), "grpc.testing.SimpleResponse")
 326         proto.RegisterType((*StreamingInputCallRequest)(nil), "grpc.testing.StreamingInputCallRequest")
 327         proto.RegisterType((*StreamingInputCallResponse)(nil), "grpc.testing.StreamingInputCallResponse")
 328         proto.RegisterType((*ResponseParameters)(nil), "grpc.testing.ResponseParameters")
 329         proto.RegisterType((*StreamingOutputCallRequest)(nil), "grpc.testing.StreamingOutputCallRequest")
 330         proto.RegisterType((*StreamingOutputCallResponse)(nil), "grpc.testing.StreamingOutputCallResponse")
 331         proto.RegisterEnum("grpc.testing.PayloadType", PayloadType_name, PayloadType_value)
 332 }
 333
 334 // Reference imports to suppress errors if they are not otherwise used.
 335 var _ context.Context
 336 var _ grpc.ClientConn
 337
 338 // This is a compile-time assertion to ensure that this generated file
 339 // is compatible with the grpc package it is being compiled against.
 340 const _ = grpc.SupportPackageIsVersion4
 341
 342 // Client API for TestService service
 343
 344 type TestServiceClient interface {
 345         // One empty request followed by one empty response.
 346         EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
 347         // One request followed by one response.
 348         // The server returns the client payload as-is.
 349         UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
 350         // One request followed by a sequence of responses (streamed download).
 351         // The server returns the payload with client desired type and sizes.
 352         StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error)
 353         // A sequence of requests followed by one response (streamed upload).
 354         // The server returns the aggregated size of client payload as the result.
 355         StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error)
 356         // A sequence of requests with each request served by the server immediately.
 357         // As one request could lead to multiple responses, this interface
 358         // demonstrates the idea of full duplexing.
 359         FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error)
 360         // A sequence of requests followed by a sequence of responses.
 361         // The server buffers all the client requests and then serves them in order. A
 362         // stream of responses are returned to the client when the server starts with
 363         // first request.
 364         HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error)
 365 }
 366
 367 type testServiceClient struct {
 368         cc *grpc.ClientConn
 369 }
 370
 371 func NewTestServiceClient(cc *grpc.ClientConn) TestServiceClient {
 372         return &testServiceClient{cc}
 373 }
 374
 375 func (c *testServiceClient) EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
 376         out := new(Empty)
 377         err := grpc.Invoke(ctx, "/grpc.testing.TestService/EmptyCall", in, out, c.cc, opts...)
 378         if err != nil {
 379                 return nil, err
 380         }
 381         return out, nil
 382 }
 383
 384 func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
 385         out := new(SimpleResponse)
 386         err := grpc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, c.cc, opts...)
 387         if err != nil {
 388                 return nil, err
 389         }
 390         return out, nil
 391 }
 392
 393 func (c *testServiceClient) StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) {
 394         stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[0], c.cc, "/grpc.testing.TestService/StreamingOutputCall", opts...)
 395         if err != nil {
 396                 return nil, err
 397         }
 398         x := &testServiceStreamingOutputCallClient{stream}
 399         if err := x.ClientStream.SendMsg(in); err != nil {
 400                 return nil, err
 401         }
 402         if err := x.ClientStream.CloseSend(); err != nil {
 403                 return nil, err
 404         }
 405         return x, nil
 406 }
 407
 408 type TestService_StreamingOutputCallClient interface {
 409         Recv() (*StreamingOutputCallResponse, error)
 410         grpc.ClientStream
 411 }
 412
 413 type testServiceStreamingOutputCallClient struct {
 414         grpc.ClientStream
 415 }
 416
 417 func (x *testServiceStreamingOutputCallClient) Recv() (*StreamingOutputCallResponse, error) {
 418         m := new(StreamingOutputCallResponse)
 419         if err := x.ClientStream.RecvMsg(m); err != nil {
 420                 return nil, err
 421         }
 422         return m, nil
 423 }
 424
 425 func (c *testServiceClient) StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) {
 426         stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[1], c.cc, "/grpc.testing.TestService/StreamingInputCall", opts...)
 427         if err != nil {
 428                 return nil, err
 429         }
 430         x := &testServiceStreamingInputCallClient{stream}
 431         return x, nil
 432 }
 433
 434 type TestService_StreamingInputCallClient interface {
 435         Send(*StreamingInputCallRequest) error
 436         CloseAndRecv() (*StreamingInputCallResponse, error)
 437         grpc.ClientStream
 438 }
 439
 440 type testServiceStreamingInputCallClient struct {
 441         grpc.ClientStream
 442 }
 443
 444 func (x *testServiceStreamingInputCallClient) Send(m *StreamingInputCallRequest) error {
 445         return x.ClientStream.SendMsg(m)
 446 }
 447
 448 func (x *testServiceStreamingInputCallClient) CloseAndRecv() (*StreamingInputCallResponse, error) {
 449         if err := x.ClientStream.CloseSend(); err != nil {
 450                 return nil, err
 451         }
 452         m := new(StreamingInputCallResponse)
 453         if err := x.ClientStream.RecvMsg(m); err != nil {
 454                 return nil, err
 455         }
 456         return m, nil
 457 }
 458
 459 func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) {
 460         stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[2], c.cc, "/grpc.testing.TestService/FullDuplexCall", opts...)
 461         if err != nil {
 462                 return nil, err
 463         }
 464         x := &testServiceFullDuplexCallClient{stream}
 465         return x, nil
 466 }
 467
 468 type TestService_FullDuplexCallClient interface {
 469         Send(*StreamingOutputCallRequest) error
 470         Recv() (*StreamingOutputCallResponse, error)
 471         grpc.ClientStream
 472 }
 473
 474 type testServiceFullDuplexCallClient struct {
 475         grpc.ClientStream
 476 }
 477
 478 func (x *testServiceFullDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
 479         return x.ClientStream.SendMsg(m)
 480 }
 481
 482 func (x *testServiceFullDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
 483         m := new(StreamingOutputCallResponse)
 484         if err := x.ClientStream.RecvMsg(m); err != nil {
 485                 return nil, err
 486         }
 487         return m, nil
 488 }
 489
 490 func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) {
 491         stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[3], c.cc, "/grpc.testing.TestService/HalfDuplexCall", opts...)
 492         if err != nil {
 493                 return nil, err
 494         }
 495         x := &testServiceHalfDuplexCallClient{stream}
 496         return x, nil
 497 }
 498
 499 type TestService_HalfDuplexCallClient interface {
 500         Send(*StreamingOutputCallRequest) error
 501         Recv() (*StreamingOutputCallResponse, error)
 502         grpc.ClientStream
 503 }
 504
 505 type testServiceHalfDuplexCallClient struct {
 506         grpc.ClientStream
 507 }
 508
 509 func (x *testServiceHalfDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
 510         return x.ClientStream.SendMsg(m)
 511 }
 512
 513 func (x *testServiceHalfDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
 514         m := new(StreamingOutputCallResponse)
 515         if err := x.ClientStream.RecvMsg(m); err != nil {
 516                 return nil, err
 517         }
 518         return m, nil
 519 }
 520
 521 // Server API for TestService service
 522
 523 type TestServiceServer interface {
 524         // One empty request followed by one empty response.
 525         EmptyCall(context.Context, *Empty) (*Empty, error)
 526         // One request followed by one response.
 527         // The server returns the client payload as-is.
 528         UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
 529         // One request followed by a sequence of responses (streamed download).
 530         // The server returns the payload with client desired type and sizes.
 531         StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
 532         // A sequence of requests followed by one response (streamed upload).
 533         // The server returns the aggregated size of client payload as the result.
 534         StreamingInputCall(TestService_StreamingInputCallServer) error
 535         // A sequence of requests with each request served by the server immediately.
 536         // As one request could lead to multiple responses, this interface
 537         // demonstrates the idea of full duplexing.
 538         FullDuplexCall(TestService_FullDuplexCallServer) error
 539         // A sequence of requests followed by a sequence of responses.
 540         // The server buffers all the client requests and then serves them in order. A
 541         // stream of responses are returned to the client when the server starts with
 542         // first request.
 543         HalfDuplexCall(TestService_HalfDuplexCallServer) error
 544 }
 545
 546 func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) {
 547         s.RegisterService(&_TestService_serviceDesc, srv)
 548 }
 549
 550 func _TestService_EmptyCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 551         in := new(Empty)
 552         if err := dec(in); err != nil {
 553                 return nil, err
 554         }
 555         if interceptor == nil {
 556                 return srv.(TestServiceServer).EmptyCall(ctx, in)
 557         }
 558         info := &grpc.UnaryServerInfo{
 559                 Server:     srv,
 560                 FullMethod: "/grpc.testing.TestService/EmptyCall",
 561         }
 562         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 563                 return srv.(TestServiceServer).EmptyCall(ctx, req.(*Empty))
 564         }
 565         return interceptor(ctx, in, info, handler)
 566 }
 567
 568 func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 569         in := new(SimpleRequest)
 570         if err := dec(in); err != nil {
 571                 return nil, err
 572         }
 573         if interceptor == nil {
 574                 return srv.(TestServiceServer).UnaryCall(ctx, in)
 575         }
 576         info := &grpc.UnaryServerInfo{
 577                 Server:     srv,
 578                 FullMethod: "/grpc.testing.TestService/UnaryCall",
 579         }
 580         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 581                 return srv.(TestServiceServer).UnaryCall(ctx, req.(*SimpleRequest))
 582         }
 583         return interceptor(ctx, in, info, handler)
 584 }
 585
 586 func _TestService_StreamingOutputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
 587         m := new(StreamingOutputCallRequest)
 588         if err := stream.RecvMsg(m); err != nil {
 589                 return err
 590         }
 591         return srv.(TestServiceServer).StreamingOutputCall(m, &testServiceStreamingOutputCallServer{stream})
 592 }
 593
 594 type TestService_StreamingOutputCallServer interface {
 595         Send(*StreamingOutputCallResponse) error
 596         grpc.ServerStream
 597 }
 598
 599 type testServiceStreamingOutputCallServer struct {
 600         grpc.ServerStream
 601 }
 602
 603 func (x *testServiceStreamingOutputCallServer) Send(m *StreamingOutputCallResponse) error {
 604         return x.ServerStream.SendMsg(m)
 605 }
 606
 607 func _TestService_StreamingInputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
 608         return srv.(TestServiceServer).StreamingInputCall(&testServiceStreamingInputCallServer{stream})
 609 }
 610
 611 type TestService_StreamingInputCallServer interface {
 612         SendAndClose(*StreamingInputCallResponse) error
 613         Recv() (*StreamingInputCallRequest, error)
 614         grpc.ServerStream
 615 }
 616
 617 type testServiceStreamingInputCallServer struct {
 618         grpc.ServerStream
 619 }
 620
 621 func (x *testServiceStreamingInputCallServer) SendAndClose(m *StreamingInputCallResponse) error {
 622         return x.ServerStream.SendMsg(m)
 623 }
 624
 625 func (x *testServiceStreamingInputCallServer) Recv() (*StreamingInputCallRequest, error) {
 626         m := new(StreamingInputCallRequest)
 627         if err := x.ServerStream.RecvMsg(m); err != nil {
 628                 return nil, err
 629         }
 630         return m, nil
 631 }
 632
 633 func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
 634         return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream})
 635 }
 636
 637 type TestService_FullDuplexCallServer interface {
 638         Send(*StreamingOutputCallResponse) error
 639         Recv() (*StreamingOutputCallRequest, error)
 640         grpc.ServerStream
 641 }
 642
 643 type testServiceFullDuplexCallServer struct {
 644         grpc.ServerStream
 645 }
 646
 647 func (x *testServiceFullDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
 648         return x.ServerStream.SendMsg(m)
 649 }
 650
 651 func (x *testServiceFullDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
 652         m := new(StreamingOutputCallRequest)
 653         if err := x.ServerStream.RecvMsg(m); err != nil {
 654                 return nil, err
 655         }
 656         return m, nil
 657 }
 658
 659 func _TestService_HalfDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
 660         return srv.(TestServiceServer).HalfDuplexCall(&testServiceHalfDuplexCallServer{stream})
 661 }
 662
 663 type TestService_HalfDuplexCallServer interface {
 664         Send(*StreamingOutputCallResponse) error
 665         Recv() (*StreamingOutputCallRequest, error)
 666         grpc.ServerStream
 667 }
 668
 669 type testServiceHalfDuplexCallServer struct {
 670         grpc.ServerStream
 671 }
 672
 673 func (x *testServiceHalfDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
 674         return x.ServerStream.SendMsg(m)
 675 }
 676
 677 func (x *testServiceHalfDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
 678         m := new(StreamingOutputCallRequest)
 679         if err := x.ServerStream.RecvMsg(m); err != nil {
 680                 return nil, err
 681         }
 682         return m, nil
 683 }
 684
 685 var _TestService_serviceDesc = grpc.ServiceDesc{
 686         ServiceName: "grpc.testing.TestService",
 687         HandlerType: (*TestServiceServer)(nil),
 688         Methods: []grpc.MethodDesc{
 689                 {
 690                         MethodName: "EmptyCall",
 691                         Handler:    _TestService_EmptyCall_Handler,
 692                 },
 693                 {
 694                         MethodName: "UnaryCall",
 695                         Handler:    _TestService_UnaryCall_Handler,
 696                 },
 697         },
 698         Streams: []grpc.StreamDesc{
 699                 {
 700                         StreamName:    "StreamingOutputCall",
 701                         Handler:       _TestService_StreamingOutputCall_Handler,
 702                         ServerStreams: true,
 703                 },
 704                 {
 705                         StreamName:    "StreamingInputCall",
 706                         Handler:       _TestService_StreamingInputCall_Handler,
 707                         ClientStreams: true,
 708                 },
 709                 {
 710                         StreamName:    "FullDuplexCall",
 711                         Handler:       _TestService_FullDuplexCall_Handler,
 712                         ServerStreams: true,
 713                         ClientStreams: true,
 714                 },
 715                 {
 716                         StreamName:    "HalfDuplexCall",
 717                         Handler:       _TestService_HalfDuplexCall_Handler,
 718                         ServerStreams: true,
 719                         ClientStreams: true,
 720                 },
 721         },
 722         Metadata: "grpc_testing/test.proto",
 723 }
 724
 725 func init() { proto.RegisterFile("grpc_testing/test.proto", fileDescriptor0) }
 726
 727 var fileDescriptor0 = []byte{
 728         // 587 bytes of a gzipped FileDescriptorProto
 729         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xdb, 0x6e, 0xd3, 0x40,
 730         0x10, 0x65, 0xdb, 0xf4, 0x36, 0x49, 0xad, 0x68, 0xab, 0xaa, 0xae, 0x8b, 0x84, 0x65, 0x1e, 0x30,
 731         0x48, 0xa4, 0x28, 0x08, 0x1e, 0x41, 0xa5, 0x17, 0x51, 0x29, 0x4d, 0x82, 0x9d, 0x3c, 0x47, 0xdb,
 732         0x64, 0x6b, 0x2c, 0x39, 0xf6, 0xb2, 0x5e, 0x57, 0xa4, 0x0f, 0xfc, 0x18, 0x3f, 0xc3, 0x47, 0xf0,
 733         0x01, 0x68, 0xd7, 0x76, 0xe2, 0x24, 0xae, 0x48, 0x41, 0xf0, 0x14, 0x7b, 0xe6, 0xcc, 0x99, 0x73,
 734         0x3c, 0xb3, 0x1b, 0x38, 0xf0, 0x38, 0x1b, 0x0e, 0x04, 0x8d, 0x85, 0x1f, 0x7a, 0xc7, 0xf2, 0xb7,
 735         0xc1, 0x78, 0x24, 0x22, 0x5c, 0x93, 0x89, 0x46, 0x96, 0xb0, 0xb6, 0x60, 0xe3, 0x7c, 0xcc, 0xc4,
 736         0xc4, 0x6a, 0xc1, 0x56, 0x97, 0x4c, 0x82, 0x88, 0x8c, 0xf0, 0x4b, 0xa8, 0x88, 0x09, 0xa3, 0x3a,
 737         0x32, 0x91, 0xad, 0x35, 0x0f, 0x1b, 0xc5, 0x82, 0x46, 0x06, 0xea, 0x4d, 0x18, 0x75, 0x14, 0x0c,
 738         0x63, 0xa8, 0x5c, 0x47, 0xa3, 0x89, 0xbe, 0x66, 0x22, 0xbb, 0xe6, 0xa8, 0x67, 0xeb, 0x27, 0x82,
 739         0x5d, 0xd7, 0x1f, 0xb3, 0x80, 0x3a, 0xf4, 0x4b, 0x42, 0x63, 0x81, 0xdf, 0xc1, 0x2e, 0xa7, 0x31,
 740         0x8b, 0xc2, 0x98, 0x0e, 0x56, 0x63, 0xaf, 0xe5, 0x78, 0xf9, 0x86, 0x9f, 0x16, 0xea, 0x63, 0xff,
 741         0x8e, 0xaa, 0x76, 0x1b, 0x33, 0x90, 0xeb, 0xdf, 0x51, 0x7c, 0x0c, 0x5b, 0x2c, 0x65, 0xd0, 0xd7,
 742         0x4d, 0x64, 0x57, 0x9b, 0xfb, 0xa5, 0xf4, 0x4e, 0x8e, 0x92, 0xac, 0x37, 0x7e, 0x10, 0x0c, 0x92,
 743         0x98, 0xf2, 0x90, 0x8c, 0xa9, 0x5e, 0x31, 0x91, 0xbd, 0xed, 0xd4, 0x64, 0xb0, 0x9f, 0xc5, 0xb0,
 744         0x0d, 0x75, 0x05, 0x8a, 0x48, 0x22, 0x3e, 0x0f, 0xe2, 0x61, 0xc4, 0xa8, 0xbe, 0xa1, 0x70, 0x9a,
 745         0x8c, 0x77, 0x64, 0xd8, 0x95, 0x51, 0xeb, 0x1b, 0x68, 0xb9, 0xeb, 0x54, 0x55, 0x51, 0x11, 0x5a,
 746         0x49, 0x91, 0x01, 0xdb, 0x53, 0x31, 0xd2, 0xe2, 0x8e, 0x33, 0x7d, 0xc7, 0x4f, 0xa0, 0x5a, 0xd4,
 747         0xb0, 0xae, 0xd2, 0x10, 0xcd, 0xfa, 0xb7, 0xe0, 0xd0, 0x15, 0x9c, 0x92, 0xb1, 0x1f, 0x7a, 0x97,
 748         0x21, 0x4b, 0xc4, 0x29, 0x09, 0x82, 0x7c, 0x02, 0x0f, 0x95, 0x62, 0xf5, 0xc0, 0x28, 0x63, 0xcb,
 749         0x9c, 0xbd, 0x85, 0x03, 0xe2, 0x79, 0x9c, 0x7a, 0x44, 0xd0, 0xd1, 0x20, 0xab, 0x49, 0x47, 0x83,
 750         0xd4, 0x68, 0xf6, 0x67, 0xe9, 0x8c, 0x5a, 0xce, 0xc8, 0xba, 0x04, 0x9c, 0x73, 0x74, 0x09, 0x27,
 751         0x63, 0x2a, 0x28, 0x8f, 0xe5, 0x12, 0x15, 0x4a, 0xd5, 0xb3, 0xb4, 0xeb, 0x87, 0x82, 0xf2, 0x5b,
 752         0x22, 0x07, 0x94, 0x0d, 0x1c, 0xf2, 0x50, 0x3f, 0xb6, 0x7e, 0xa0, 0x82, 0xc2, 0x4e, 0x22, 0x16,
 753         0x0c, 0xff, 0xed, 0xca, 0x7d, 0x82, 0xbd, 0x69, 0x3d, 0x9b, 0x4a, 0xd5, 0xd7, 0xcc, 0x75, 0xbb,
 754         0xda, 0x34, 0xe7, 0x59, 0x96, 0x2d, 0x39, 0x98, 0x2f, 0xdb, 0x7c, 0xe8, 0x82, 0x5a, 0x6d, 0x38,
 755         0x2a, 0x75, 0xf8, 0x87, 0xeb, 0xf5, 0xe2, 0x3d, 0x54, 0x0b, 0x86, 0x71, 0x1d, 0x6a, 0xa7, 0x9d,
 756         0xab, 0xae, 0x73, 0xee, 0xba, 0x27, 0x1f, 0x5a, 0xe7, 0xf5, 0x47, 0x18, 0x83, 0xd6, 0x6f, 0xcf,
 757         0xc5, 0x10, 0x06, 0xd8, 0x74, 0x4e, 0xda, 0x67, 0x9d, 0xab, 0xfa, 0x5a, 0xf3, 0x7b, 0x05, 0xaa,
 758         0x3d, 0x1a, 0x0b, 0x97, 0xf2, 0x5b, 0x7f, 0x48, 0xf1, 0x1b, 0xd8, 0x51, 0x17, 0x88, 0x94, 0x85,
 759         0xf7, 0xe6, 0xbb, 0xab, 0x84, 0x51, 0x16, 0xc4, 0x17, 0xb0, 0xd3, 0x0f, 0x09, 0x4f, 0xcb, 0x8e,
 760         0xe6, 0x11, 0x73, 0x17, 0x87, 0xf1, 0xb8, 0x3c, 0x99, 0x7d, 0x80, 0x00, 0xf6, 0x4a, 0xbe, 0x0f,
 761         0xb6, 0x17, 0x8a, 0xee, 0x5d, 0x12, 0xe3, 0xf9, 0x0a, 0xc8, 0xb4, 0xd7, 0x2b, 0x84, 0x7d, 0xc0,
 762         0xcb, 0x27, 0x02, 0x3f, 0xbb, 0x87, 0x62, 0xf1, 0x04, 0x1a, 0xf6, 0xef, 0x81, 0x69, 0x2b, 0x5b,
 763         0xb6, 0xd2, 0x2e, 0x92, 0x20, 0x38, 0x4b, 0x58, 0x40, 0xbf, 0xfe, 0x33, 0x4f, 0x36, 0x52, 0xae,
 764         0xb4, 0x8f, 0x24, 0xb8, 0xf9, 0x0f, 0xad, 0xae, 0x37, 0xd5, 0x7f, 0xd0, 0xeb, 0x5f, 0x01, 0x00,
 765         0x00, 0xff, 0xff, 0x07, 0xc7, 0x76, 0x69, 0x9e, 0x06, 0x00, 0x00,
 766 }