| // 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. |
| |
| // Code generated by protoc-gen-go-grpc. DO NOT EDIT. |
| // versions: |
| // - protoc-gen-go-grpc v1.3.0 |
| // - protoc v4.22.0 |
| // source: test/grpc_testing/test.proto |
| |
| package grpc_testing |
| |
| import ( |
| context "context" |
| grpc "google.golang.org/grpc" |
| codes "google.golang.org/grpc/codes" |
| status "google.golang.org/grpc/status" |
| ) |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the grpc package it is being compiled against. |
| // Requires gRPC-Go v1.32.0 or later. |
| const _ = grpc.SupportPackageIsVersion7 |
| |
| const ( |
| TestService_EmptyCall_FullMethodName = "/grpc.testing.TestService/EmptyCall" |
| TestService_UnaryCall_FullMethodName = "/grpc.testing.TestService/UnaryCall" |
| TestService_StreamingOutputCall_FullMethodName = "/grpc.testing.TestService/StreamingOutputCall" |
| TestService_StreamingInputCall_FullMethodName = "/grpc.testing.TestService/StreamingInputCall" |
| TestService_FullDuplexCall_FullMethodName = "/grpc.testing.TestService/FullDuplexCall" |
| TestService_HalfDuplexCall_FullMethodName = "/grpc.testing.TestService/HalfDuplexCall" |
| ) |
| |
| // TestServiceClient is the client API for TestService service. |
| // |
| // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. |
| type TestServiceClient interface { |
| // One empty request followed by one empty response. |
| EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) |
| // One request followed by one response. |
| // The server returns the client payload as-is. |
| UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) |
| // One request followed by a sequence of responses (streamed download). |
| // The server returns the payload with client desired type and sizes. |
| StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) |
| // A sequence of requests followed by one response (streamed upload). |
| // The server returns the aggregated size of client payload as the result. |
| StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) |
| // 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. |
| FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) |
| // 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. |
| HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) |
| } |
| |
| type testServiceClient struct { |
| cc grpc.ClientConnInterface |
| } |
| |
| func NewTestServiceClient(cc grpc.ClientConnInterface) TestServiceClient { |
| return &testServiceClient{cc} |
| } |
| |
| func (c *testServiceClient) EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) { |
| out := new(Empty) |
| err := c.cc.Invoke(ctx, TestService_EmptyCall_FullMethodName, in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) { |
| out := new(SimpleResponse) |
| err := c.cc.Invoke(ctx, TestService_UnaryCall_FullMethodName, in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *testServiceClient) StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) { |
| stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[0], TestService_StreamingOutputCall_FullMethodName, opts...) |
| if err != nil { |
| return nil, err |
| } |
| x := &testServiceStreamingOutputCallClient{stream} |
| if err := x.ClientStream.SendMsg(in); err != nil { |
| return nil, err |
| } |
| if err := x.ClientStream.CloseSend(); err != nil { |
| return nil, err |
| } |
| return x, nil |
| } |
| |
| type TestService_StreamingOutputCallClient interface { |
| Recv() (*StreamingOutputCallResponse, error) |
| grpc.ClientStream |
| } |
| |
| type testServiceStreamingOutputCallClient struct { |
| grpc.ClientStream |
| } |
| |
| func (x *testServiceStreamingOutputCallClient) Recv() (*StreamingOutputCallResponse, error) { |
| m := new(StreamingOutputCallResponse) |
| if err := x.ClientStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| func (c *testServiceClient) StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) { |
| stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[1], TestService_StreamingInputCall_FullMethodName, opts...) |
| if err != nil { |
| return nil, err |
| } |
| x := &testServiceStreamingInputCallClient{stream} |
| return x, nil |
| } |
| |
| type TestService_StreamingInputCallClient interface { |
| Send(*StreamingInputCallRequest) error |
| CloseAndRecv() (*StreamingInputCallResponse, error) |
| grpc.ClientStream |
| } |
| |
| type testServiceStreamingInputCallClient struct { |
| grpc.ClientStream |
| } |
| |
| func (x *testServiceStreamingInputCallClient) Send(m *StreamingInputCallRequest) error { |
| return x.ClientStream.SendMsg(m) |
| } |
| |
| func (x *testServiceStreamingInputCallClient) CloseAndRecv() (*StreamingInputCallResponse, error) { |
| if err := x.ClientStream.CloseSend(); err != nil { |
| return nil, err |
| } |
| m := new(StreamingInputCallResponse) |
| if err := x.ClientStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) { |
| stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[2], TestService_FullDuplexCall_FullMethodName, opts...) |
| if err != nil { |
| return nil, err |
| } |
| x := &testServiceFullDuplexCallClient{stream} |
| return x, nil |
| } |
| |
| type TestService_FullDuplexCallClient interface { |
| Send(*StreamingOutputCallRequest) error |
| Recv() (*StreamingOutputCallResponse, error) |
| grpc.ClientStream |
| } |
| |
| type testServiceFullDuplexCallClient struct { |
| grpc.ClientStream |
| } |
| |
| func (x *testServiceFullDuplexCallClient) Send(m *StreamingOutputCallRequest) error { |
| return x.ClientStream.SendMsg(m) |
| } |
| |
| func (x *testServiceFullDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) { |
| m := new(StreamingOutputCallResponse) |
| if err := x.ClientStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) { |
| stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[3], TestService_HalfDuplexCall_FullMethodName, opts...) |
| if err != nil { |
| return nil, err |
| } |
| x := &testServiceHalfDuplexCallClient{stream} |
| return x, nil |
| } |
| |
| type TestService_HalfDuplexCallClient interface { |
| Send(*StreamingOutputCallRequest) error |
| Recv() (*StreamingOutputCallResponse, error) |
| grpc.ClientStream |
| } |
| |
| type testServiceHalfDuplexCallClient struct { |
| grpc.ClientStream |
| } |
| |
| func (x *testServiceHalfDuplexCallClient) Send(m *StreamingOutputCallRequest) error { |
| return x.ClientStream.SendMsg(m) |
| } |
| |
| func (x *testServiceHalfDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) { |
| m := new(StreamingOutputCallResponse) |
| if err := x.ClientStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| // TestServiceServer is the server API for TestService service. |
| // All implementations must embed UnimplementedTestServiceServer |
| // for forward compatibility |
| type TestServiceServer interface { |
| // One empty request followed by one empty response. |
| EmptyCall(context.Context, *Empty) (*Empty, error) |
| // One request followed by one response. |
| // The server returns the client payload as-is. |
| UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) |
| // One request followed by a sequence of responses (streamed download). |
| // The server returns the payload with client desired type and sizes. |
| StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error |
| // A sequence of requests followed by one response (streamed upload). |
| // The server returns the aggregated size of client payload as the result. |
| StreamingInputCall(TestService_StreamingInputCallServer) error |
| // 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. |
| FullDuplexCall(TestService_FullDuplexCallServer) error |
| // 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. |
| HalfDuplexCall(TestService_HalfDuplexCallServer) error |
| mustEmbedUnimplementedTestServiceServer() |
| } |
| |
| // UnimplementedTestServiceServer must be embedded to have forward compatible implementations. |
| type UnimplementedTestServiceServer struct { |
| } |
| |
| func (UnimplementedTestServiceServer) EmptyCall(context.Context, *Empty) (*Empty, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method EmptyCall not implemented") |
| } |
| func (UnimplementedTestServiceServer) UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method UnaryCall not implemented") |
| } |
| func (UnimplementedTestServiceServer) StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error { |
| return status.Errorf(codes.Unimplemented, "method StreamingOutputCall not implemented") |
| } |
| func (UnimplementedTestServiceServer) StreamingInputCall(TestService_StreamingInputCallServer) error { |
| return status.Errorf(codes.Unimplemented, "method StreamingInputCall not implemented") |
| } |
| func (UnimplementedTestServiceServer) FullDuplexCall(TestService_FullDuplexCallServer) error { |
| return status.Errorf(codes.Unimplemented, "method FullDuplexCall not implemented") |
| } |
| func (UnimplementedTestServiceServer) HalfDuplexCall(TestService_HalfDuplexCallServer) error { |
| return status.Errorf(codes.Unimplemented, "method HalfDuplexCall not implemented") |
| } |
| func (UnimplementedTestServiceServer) mustEmbedUnimplementedTestServiceServer() {} |
| |
| // UnsafeTestServiceServer may be embedded to opt out of forward compatibility for this service. |
| // Use of this interface is not recommended, as added methods to TestServiceServer will |
| // result in compilation errors. |
| type UnsafeTestServiceServer interface { |
| mustEmbedUnimplementedTestServiceServer() |
| } |
| |
| func RegisterTestServiceServer(s grpc.ServiceRegistrar, srv TestServiceServer) { |
| s.RegisterService(&TestService_ServiceDesc, srv) |
| } |
| |
| func _TestService_EmptyCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(Empty) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(TestServiceServer).EmptyCall(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: TestService_EmptyCall_FullMethodName, |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(TestServiceServer).EmptyCall(ctx, req.(*Empty)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(SimpleRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(TestServiceServer).UnaryCall(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: TestService_UnaryCall_FullMethodName, |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(TestServiceServer).UnaryCall(ctx, req.(*SimpleRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _TestService_StreamingOutputCall_Handler(srv interface{}, stream grpc.ServerStream) error { |
| m := new(StreamingOutputCallRequest) |
| if err := stream.RecvMsg(m); err != nil { |
| return err |
| } |
| return srv.(TestServiceServer).StreamingOutputCall(m, &testServiceStreamingOutputCallServer{stream}) |
| } |
| |
| type TestService_StreamingOutputCallServer interface { |
| Send(*StreamingOutputCallResponse) error |
| grpc.ServerStream |
| } |
| |
| type testServiceStreamingOutputCallServer struct { |
| grpc.ServerStream |
| } |
| |
| func (x *testServiceStreamingOutputCallServer) Send(m *StreamingOutputCallResponse) error { |
| return x.ServerStream.SendMsg(m) |
| } |
| |
| func _TestService_StreamingInputCall_Handler(srv interface{}, stream grpc.ServerStream) error { |
| return srv.(TestServiceServer).StreamingInputCall(&testServiceStreamingInputCallServer{stream}) |
| } |
| |
| type TestService_StreamingInputCallServer interface { |
| SendAndClose(*StreamingInputCallResponse) error |
| Recv() (*StreamingInputCallRequest, error) |
| grpc.ServerStream |
| } |
| |
| type testServiceStreamingInputCallServer struct { |
| grpc.ServerStream |
| } |
| |
| func (x *testServiceStreamingInputCallServer) SendAndClose(m *StreamingInputCallResponse) error { |
| return x.ServerStream.SendMsg(m) |
| } |
| |
| func (x *testServiceStreamingInputCallServer) Recv() (*StreamingInputCallRequest, error) { |
| m := new(StreamingInputCallRequest) |
| if err := x.ServerStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error { |
| return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream}) |
| } |
| |
| type TestService_FullDuplexCallServer interface { |
| Send(*StreamingOutputCallResponse) error |
| Recv() (*StreamingOutputCallRequest, error) |
| grpc.ServerStream |
| } |
| |
| type testServiceFullDuplexCallServer struct { |
| grpc.ServerStream |
| } |
| |
| func (x *testServiceFullDuplexCallServer) Send(m *StreamingOutputCallResponse) error { |
| return x.ServerStream.SendMsg(m) |
| } |
| |
| func (x *testServiceFullDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) { |
| m := new(StreamingOutputCallRequest) |
| if err := x.ServerStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| func _TestService_HalfDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error { |
| return srv.(TestServiceServer).HalfDuplexCall(&testServiceHalfDuplexCallServer{stream}) |
| } |
| |
| type TestService_HalfDuplexCallServer interface { |
| Send(*StreamingOutputCallResponse) error |
| Recv() (*StreamingOutputCallRequest, error) |
| grpc.ServerStream |
| } |
| |
| type testServiceHalfDuplexCallServer struct { |
| grpc.ServerStream |
| } |
| |
| func (x *testServiceHalfDuplexCallServer) Send(m *StreamingOutputCallResponse) error { |
| return x.ServerStream.SendMsg(m) |
| } |
| |
| func (x *testServiceHalfDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) { |
| m := new(StreamingOutputCallRequest) |
| if err := x.ServerStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| // TestService_ServiceDesc is the grpc.ServiceDesc for TestService service. |
| // It's only intended for direct use with grpc.RegisterService, |
| // and not to be introspected or modified (even as a copy) |
| var TestService_ServiceDesc = grpc.ServiceDesc{ |
| ServiceName: "grpc.testing.TestService", |
| HandlerType: (*TestServiceServer)(nil), |
| Methods: []grpc.MethodDesc{ |
| { |
| MethodName: "EmptyCall", |
| Handler: _TestService_EmptyCall_Handler, |
| }, |
| { |
| MethodName: "UnaryCall", |
| Handler: _TestService_UnaryCall_Handler, |
| }, |
| }, |
| Streams: []grpc.StreamDesc{ |
| { |
| StreamName: "StreamingOutputCall", |
| Handler: _TestService_StreamingOutputCall_Handler, |
| ServerStreams: true, |
| }, |
| { |
| StreamName: "StreamingInputCall", |
| Handler: _TestService_StreamingInputCall_Handler, |
| ClientStreams: true, |
| }, |
| { |
| StreamName: "FullDuplexCall", |
| Handler: _TestService_FullDuplexCall_Handler, |
| ServerStreams: true, |
| ClientStreams: true, |
| }, |
| { |
| StreamName: "HalfDuplexCall", |
| Handler: _TestService_HalfDuplexCall_Handler, |
| ServerStreams: true, |
| ClientStreams: true, |
| }, |
| }, |
| Metadata: "test/grpc_testing/test.proto", |
| } |