mocks

package

Go to main page

Versions in this module

v0

v0.1.9

Sep 2, 2024

v0.1.8

Aug 30, 2024

Changes in this version

+ type MockServerStreamingClient struct

+ func NewMockServerStreamingClient[Res interface{}](t interface{ ... }) *MockServerStreamingClient[Res]

+ func (_m *MockServerStreamingClient[Res]) CloseSend() error

+ func (_m *MockServerStreamingClient[Res]) Context() context.Context

+ func (_m *MockServerStreamingClient[Res]) EXPECT() *MockServerStreamingClient_Expecter[Res]

+ func (_m *MockServerStreamingClient[Res]) Header() (metadata.MD, error)

+ func (_m *MockServerStreamingClient[Res]) Recv() (*testproto.Msg, error)

+ func (_m *MockServerStreamingClient[Res]) RecvMsg(m interface{}) error

+ func (_m *MockServerStreamingClient[Res]) SendMsg(m interface{}) error

+ func (_m *MockServerStreamingClient[Res]) Trailer() metadata.MD

+ type MockServerStreamingClient_CloseSend_Call struct

+ func (_c *MockServerStreamingClient_CloseSend_Call[Res]) Return(_a0 error) *MockServerStreamingClient_CloseSend_Call[Res]

+ func (_c *MockServerStreamingClient_CloseSend_Call[Res]) Run(run func()) *MockServerStreamingClient_CloseSend_Call[Res]

+ func (_c *MockServerStreamingClient_CloseSend_Call[Res]) RunAndReturn(run func() error) *MockServerStreamingClient_CloseSend_Call[Res]

+ type MockServerStreamingClient_Context_Call struct

+ func (_c *MockServerStreamingClient_Context_Call[Res]) Return(_a0 context.Context) *MockServerStreamingClient_Context_Call[Res]

+ func (_c *MockServerStreamingClient_Context_Call[Res]) Run(run func()) *MockServerStreamingClient_Context_Call[Res]

+ func (_c *MockServerStreamingClient_Context_Call[Res]) RunAndReturn(run func() context.Context) *MockServerStreamingClient_Context_Call[Res]

+ type MockServerStreamingClient_Expecter struct

+ func (_e *MockServerStreamingClient_Expecter[Res]) CloseSend() *MockServerStreamingClient_CloseSend_Call[Res]

+ func (_e *MockServerStreamingClient_Expecter[Res]) Context() *MockServerStreamingClient_Context_Call[Res]

+ func (_e *MockServerStreamingClient_Expecter[Res]) Header() *MockServerStreamingClient_Header_Call[Res]

+ func (_e *MockServerStreamingClient_Expecter[Res]) Recv() *MockServerStreamingClient_Recv_Call[Res]

+ func (_e *MockServerStreamingClient_Expecter[Res]) RecvMsg(m interface{}) *MockServerStreamingClient_RecvMsg_Call[Res]

+ func (_e *MockServerStreamingClient_Expecter[Res]) SendMsg(m interface{}) *MockServerStreamingClient_SendMsg_Call[Res]

+ func (_e *MockServerStreamingClient_Expecter[Res]) Trailer() *MockServerStreamingClient_Trailer_Call[Res]

+ type MockServerStreamingClient_Header_Call struct

+ func (_c *MockServerStreamingClient_Header_Call[Res]) Return(_a0 metadata.MD, _a1 error) *MockServerStreamingClient_Header_Call[Res]

+ func (_c *MockServerStreamingClient_Header_Call[Res]) Run(run func()) *MockServerStreamingClient_Header_Call[Res]

+ func (_c *MockServerStreamingClient_Header_Call[Res]) RunAndReturn(run func() (metadata.MD, error)) *MockServerStreamingClient_Header_Call[Res]

+ type MockServerStreamingClient_RecvMsg_Call struct

+ func (_c *MockServerStreamingClient_RecvMsg_Call[Res]) Return(_a0 error) *MockServerStreamingClient_RecvMsg_Call[Res]

+ func (_c *MockServerStreamingClient_RecvMsg_Call[Res]) Run(run func(m interface{})) *MockServerStreamingClient_RecvMsg_Call[Res]

+ func (_c *MockServerStreamingClient_RecvMsg_Call[Res]) RunAndReturn(run func(interface{}) error) *MockServerStreamingClient_RecvMsg_Call[Res]

+ type MockServerStreamingClient_Recv_Call struct

+ func (_c *MockServerStreamingClient_Recv_Call[Res]) Return(_a0 *testproto.Msg, _a1 error) *MockServerStreamingClient_Recv_Call[Res]

+ func (_c *MockServerStreamingClient_Recv_Call[Res]) Run(run func()) *MockServerStreamingClient_Recv_Call[Res]

+ func (_c *MockServerStreamingClient_Recv_Call[Res]) RunAndReturn(run func() (*testproto.Msg, error)) *MockServerStreamingClient_Recv_Call[Res]

+ type MockServerStreamingClient_SendMsg_Call struct

+ func (_c *MockServerStreamingClient_SendMsg_Call[Res]) Return(_a0 error) *MockServerStreamingClient_SendMsg_Call[Res]

+ func (_c *MockServerStreamingClient_SendMsg_Call[Res]) Run(run func(m interface{})) *MockServerStreamingClient_SendMsg_Call[Res]

+ func (_c *MockServerStreamingClient_SendMsg_Call[Res]) RunAndReturn(run func(interface{}) error) *MockServerStreamingClient_SendMsg_Call[Res]

+ type MockServerStreamingClient_Trailer_Call struct

+ func (_c *MockServerStreamingClient_Trailer_Call[Res]) Return(_a0 metadata.MD) *MockServerStreamingClient_Trailer_Call[Res]

+ func (_c *MockServerStreamingClient_Trailer_Call[Res]) Run(run func()) *MockServerStreamingClient_Trailer_Call[Res]

+ func (_c *MockServerStreamingClient_Trailer_Call[Res]) RunAndReturn(run func() metadata.MD) *MockServerStreamingClient_Trailer_Call[Res]

+ type MockServerStreamingServer struct

+ func NewMockServerStreamingServer[Res interface{}](t interface{ ... }) *MockServerStreamingServer[Res]

+ func (_m *MockServerStreamingServer[Res]) Context() context.Context

+ func (_m *MockServerStreamingServer[Res]) EXPECT() *MockServerStreamingServer_Expecter[Res]

+ func (_m *MockServerStreamingServer[Res]) RecvMsg(m interface{}) error

+ func (_m *MockServerStreamingServer[Res]) Send(_a0 *testproto.Msg) error

+ func (_m *MockServerStreamingServer[Res]) SendHeader(_a0 metadata.MD) error

+ func (_m *MockServerStreamingServer[Res]) SendMsg(m interface{}) error

+ func (_m *MockServerStreamingServer[Res]) SetHeader(_a0 metadata.MD) error

+ func (_m *MockServerStreamingServer[Res]) SetTrailer(_a0 metadata.MD)

+ type MockServerStreamingServer_Context_Call struct

+ func (_c *MockServerStreamingServer_Context_Call[Res]) Return(_a0 context.Context) *MockServerStreamingServer_Context_Call[Res]

+ func (_c *MockServerStreamingServer_Context_Call[Res]) Run(run func()) *MockServerStreamingServer_Context_Call[Res]

+ func (_c *MockServerStreamingServer_Context_Call[Res]) RunAndReturn(run func() context.Context) *MockServerStreamingServer_Context_Call[Res]

+ type MockServerStreamingServer_Expecter struct

+ func (_e *MockServerStreamingServer_Expecter[Res]) Context() *MockServerStreamingServer_Context_Call[Res]

+ func (_e *MockServerStreamingServer_Expecter[Res]) RecvMsg(m interface{}) *MockServerStreamingServer_RecvMsg_Call[Res]

+ func (_e *MockServerStreamingServer_Expecter[Res]) Send(_a0 interface{}) *MockServerStreamingServer_Send_Call[Res]

+ func (_e *MockServerStreamingServer_Expecter[Res]) SendHeader(_a0 interface{}) *MockServerStreamingServer_SendHeader_Call[Res]

+ func (_e *MockServerStreamingServer_Expecter[Res]) SendMsg(m interface{}) *MockServerStreamingServer_SendMsg_Call[Res]

+ func (_e *MockServerStreamingServer_Expecter[Res]) SetHeader(_a0 interface{}) *MockServerStreamingServer_SetHeader_Call[Res]

+ func (_e *MockServerStreamingServer_Expecter[Res]) SetTrailer(_a0 interface{}) *MockServerStreamingServer_SetTrailer_Call[Res]

+ type MockServerStreamingServer_RecvMsg_Call struct

+ func (_c *MockServerStreamingServer_RecvMsg_Call[Res]) Return(_a0 error) *MockServerStreamingServer_RecvMsg_Call[Res]

+ func (_c *MockServerStreamingServer_RecvMsg_Call[Res]) Run(run func(m interface{})) *MockServerStreamingServer_RecvMsg_Call[Res]

+ func (_c *MockServerStreamingServer_RecvMsg_Call[Res]) RunAndReturn(run func(interface{}) error) *MockServerStreamingServer_RecvMsg_Call[Res]

+ type MockServerStreamingServer_SendHeader_Call struct

+ func (_c *MockServerStreamingServer_SendHeader_Call[Res]) Return(_a0 error) *MockServerStreamingServer_SendHeader_Call[Res]

+ func (_c *MockServerStreamingServer_SendHeader_Call[Res]) Run(run func(_a0 metadata.MD)) *MockServerStreamingServer_SendHeader_Call[Res]

+ func (_c *MockServerStreamingServer_SendHeader_Call[Res]) RunAndReturn(run func(metadata.MD) error) *MockServerStreamingServer_SendHeader_Call[Res]

+ type MockServerStreamingServer_SendMsg_Call struct

+ func (_c *MockServerStreamingServer_SendMsg_Call[Res]) Return(_a0 error) *MockServerStreamingServer_SendMsg_Call[Res]

+ func (_c *MockServerStreamingServer_SendMsg_Call[Res]) Run(run func(m interface{})) *MockServerStreamingServer_SendMsg_Call[Res]

+ func (_c *MockServerStreamingServer_SendMsg_Call[Res]) RunAndReturn(run func(interface{}) error) *MockServerStreamingServer_SendMsg_Call[Res]

+ type MockServerStreamingServer_Send_Call struct

+ func (_c *MockServerStreamingServer_Send_Call[Res]) Return(_a0 error) *MockServerStreamingServer_Send_Call[Res]

+ func (_c *MockServerStreamingServer_Send_Call[Res]) Run(run func(_a0 *testproto.Msg)) *MockServerStreamingServer_Send_Call[Res]

+ func (_c *MockServerStreamingServer_Send_Call[Res]) RunAndReturn(run func(*testproto.Msg) error) *MockServerStreamingServer_Send_Call[Res]

+ type MockServerStreamingServer_SetHeader_Call struct

+ func (_c *MockServerStreamingServer_SetHeader_Call[Res]) Return(_a0 error) *MockServerStreamingServer_SetHeader_Call[Res]

+ func (_c *MockServerStreamingServer_SetHeader_Call[Res]) Run(run func(_a0 metadata.MD)) *MockServerStreamingServer_SetHeader_Call[Res]

+ func (_c *MockServerStreamingServer_SetHeader_Call[Res]) RunAndReturn(run func(metadata.MD) error) *MockServerStreamingServer_SetHeader_Call[Res]

+ type MockServerStreamingServer_SetTrailer_Call struct

+ func (_c *MockServerStreamingServer_SetTrailer_Call[Res]) Return() *MockServerStreamingServer_SetTrailer_Call[Res]

+ func (_c *MockServerStreamingServer_SetTrailer_Call[Res]) Run(run func(_a0 metadata.MD)) *MockServerStreamingServer_SetTrailer_Call[Res]

+ func (_c *MockServerStreamingServer_SetTrailer_Call[Res]) RunAndReturn(run func(metadata.MD)) *MockServerStreamingServer_SetTrailer_Call[Res]

v0.1.7

Aug 29, 2024

v0.1.6

May 3, 2024

v0.1.5

Mar 7, 2024

v0.1.4

Mar 1, 2024

v0.1.3

Feb 19, 2024

Changes in this version

type MockTestServiceClient

+ func (_m *MockTestServiceClient) ServerStreamThatSleeps(ctx context.Context, in *testproto.Msg, opts ...grpc.CallOption) (testproto.TestService_ServerStreamThatSleepsClient, error)

type MockTestServiceClient_Expecter

+ func (_e *MockTestServiceClient_Expecter) ServerStreamThatSleeps(ctx interface{}, in interface{}, opts ...interface{}) *MockTestServiceClient_ServerStreamThatSleeps_Call

+ type MockTestServiceClient_ServerStreamThatSleeps_Call struct

+ func (_c *MockTestServiceClient_ServerStreamThatSleeps_Call) Return(_a0 testproto.TestService_ServerStreamThatSleepsClient, _a1 error) *MockTestServiceClient_ServerStreamThatSleeps_Call

+ func (_c *MockTestServiceClient_ServerStreamThatSleeps_Call) Run(run func(ctx context.Context, in *testproto.Msg, opts ...grpc.CallOption)) *MockTestServiceClient_ServerStreamThatSleeps_Call

+ func (_c *MockTestServiceClient_ServerStreamThatSleeps_Call) RunAndReturn(...) *MockTestServiceClient_ServerStreamThatSleeps_Call

type MockTestServiceServer

+ func (_m *MockTestServiceServer) ServerStreamThatSleeps(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamThatSleepsServer) error

type MockTestServiceServer_Expecter

+ func (_e *MockTestServiceServer_Expecter) ServerStreamThatSleeps(_a0 interface{}, _a1 interface{}) *MockTestServiceServer_ServerStreamThatSleeps_Call

+ type MockTestServiceServer_ServerStreamThatSleeps_Call struct

+ func (_c *MockTestServiceServer_ServerStreamThatSleeps_Call) Return(_a0 error) *MockTestServiceServer_ServerStreamThatSleeps_Call

+ func (_c *MockTestServiceServer_ServerStreamThatSleeps_Call) Run(...) *MockTestServiceServer_ServerStreamThatSleeps_Call

+ func (_c *MockTestServiceServer_ServerStreamThatSleeps_Call) RunAndReturn(...) *MockTestServiceServer_ServerStreamThatSleeps_Call

+ type MockTestService_ServerStreamThatSleepsClient struct

+ func NewMockTestService_ServerStreamThatSleepsClient(t interface{ ... }) *MockTestService_ServerStreamThatSleepsClient

+ func (_m *MockTestService_ServerStreamThatSleepsClient) CloseSend() error

+ func (_m *MockTestService_ServerStreamThatSleepsClient) Context() context.Context

+ func (_m *MockTestService_ServerStreamThatSleepsClient) EXPECT() *MockTestService_ServerStreamThatSleepsClient_Expecter

+ func (_m *MockTestService_ServerStreamThatSleepsClient) Header() (metadata.MD, error)

+ func (_m *MockTestService_ServerStreamThatSleepsClient) Recv() (*testproto.Msg, error)

+ func (_m *MockTestService_ServerStreamThatSleepsClient) RecvMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamThatSleepsClient) SendMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamThatSleepsClient) Trailer() metadata.MD

+ type MockTestService_ServerStreamThatSleepsClient_CloseSend_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call) Run(run func()) *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call) RunAndReturn(run func() error) *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call

+ type MockTestService_ServerStreamThatSleepsClient_Context_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Context_Call) Return(_a0 context.Context) *MockTestService_ServerStreamThatSleepsClient_Context_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Context_Call) Run(run func()) *MockTestService_ServerStreamThatSleepsClient_Context_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_ServerStreamThatSleepsClient_Context_Call

+ type MockTestService_ServerStreamThatSleepsClient_Expecter struct

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) CloseSend() *MockTestService_ServerStreamThatSleepsClient_CloseSend_Call

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) Context() *MockTestService_ServerStreamThatSleepsClient_Context_Call

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) Header() *MockTestService_ServerStreamThatSleepsClient_Header_Call

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) Recv() *MockTestService_ServerStreamThatSleepsClient_Recv_Call

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) RecvMsg(m interface{}) *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) SendMsg(m interface{}) *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call

+ func (_e *MockTestService_ServerStreamThatSleepsClient_Expecter) Trailer() *MockTestService_ServerStreamThatSleepsClient_Trailer_Call

+ type MockTestService_ServerStreamThatSleepsClient_Header_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *MockTestService_ServerStreamThatSleepsClient_Header_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Header_Call) Run(run func()) *MockTestService_ServerStreamThatSleepsClient_Header_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *MockTestService_ServerStreamThatSleepsClient_Header_Call

+ type MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamThatSleepsClient_RecvMsg_Call

+ type MockTestService_ServerStreamThatSleepsClient_Recv_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Recv_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestService_ServerStreamThatSleepsClient_Recv_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Recv_Call) Run(run func()) *MockTestService_ServerStreamThatSleepsClient_Recv_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Recv_Call) RunAndReturn(run func() (*testproto.Msg, error)) *MockTestService_ServerStreamThatSleepsClient_Recv_Call

+ type MockTestService_ServerStreamThatSleepsClient_SendMsg_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamThatSleepsClient_SendMsg_Call

+ type MockTestService_ServerStreamThatSleepsClient_Trailer_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Trailer_Call) Return(_a0 metadata.MD) *MockTestService_ServerStreamThatSleepsClient_Trailer_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Trailer_Call) Run(run func()) *MockTestService_ServerStreamThatSleepsClient_Trailer_Call

+ func (_c *MockTestService_ServerStreamThatSleepsClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *MockTestService_ServerStreamThatSleepsClient_Trailer_Call

+ type MockTestService_ServerStreamThatSleepsServer struct

+ func NewMockTestService_ServerStreamThatSleepsServer(t interface{ ... }) *MockTestService_ServerStreamThatSleepsServer

+ func (_m *MockTestService_ServerStreamThatSleepsServer) Context() context.Context

+ func (_m *MockTestService_ServerStreamThatSleepsServer) EXPECT() *MockTestService_ServerStreamThatSleepsServer_Expecter

+ func (_m *MockTestService_ServerStreamThatSleepsServer) RecvMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamThatSleepsServer) Send(_a0 *testproto.Msg) error

+ func (_m *MockTestService_ServerStreamThatSleepsServer) SendHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_ServerStreamThatSleepsServer) SendMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamThatSleepsServer) SetHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_ServerStreamThatSleepsServer) SetTrailer(_a0 metadata.MD)

+ type MockTestService_ServerStreamThatSleepsServer_Context_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_Context_Call) Return(_a0 context.Context) *MockTestService_ServerStreamThatSleepsServer_Context_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_Context_Call) Run(run func()) *MockTestService_ServerStreamThatSleepsServer_Context_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_ServerStreamThatSleepsServer_Context_Call

+ type MockTestService_ServerStreamThatSleepsServer_Expecter struct

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) Context() *MockTestService_ServerStreamThatSleepsServer_Context_Call

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) RecvMsg(m interface{}) *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) Send(_a0 interface{}) *MockTestService_ServerStreamThatSleepsServer_Send_Call

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) SendHeader(_a0 interface{}) *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) SendMsg(m interface{}) *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) SetHeader(_a0 interface{}) *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call

+ func (_e *MockTestService_ServerStreamThatSleepsServer_Expecter) SetTrailer(_a0 interface{}) *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call

+ type MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamThatSleepsServer_RecvMsg_Call

+ type MockTestService_ServerStreamThatSleepsServer_SendHeader_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_ServerStreamThatSleepsServer_SendHeader_Call

+ type MockTestService_ServerStreamThatSleepsServer_SendMsg_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamThatSleepsServer_SendMsg_Call

+ type MockTestService_ServerStreamThatSleepsServer_Send_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_Send_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsServer_Send_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_Send_Call) Run(run func(_a0 *testproto.Msg)) *MockTestService_ServerStreamThatSleepsServer_Send_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_Send_Call) RunAndReturn(run func(*testproto.Msg) error) *MockTestService_ServerStreamThatSleepsServer_Send_Call

+ type MockTestService_ServerStreamThatSleepsServer_SetHeader_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call) Return(_a0 error) *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_ServerStreamThatSleepsServer_SetHeader_Call

+ type MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call struct

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call) Return() *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call

+ func (_c *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *MockTestService_ServerStreamThatSleepsServer_SetTrailer_Call

v0.1.2

Feb 1, 2024

v0.1.1

Jan 23, 2024

Changes in this version

+ type MockTestServiceClient struct

+ func NewMockTestServiceClient(t interface{ ... }) *MockTestServiceClient

+ func (_m *MockTestServiceClient) BidiStream(ctx context.Context, opts ...grpc.CallOption) (testproto.TestService_BidiStreamClient, error)

+ func (_m *MockTestServiceClient) ClientStream(ctx context.Context, opts ...grpc.CallOption) (testproto.TestService_ClientStreamClient, error)

+ func (_m *MockTestServiceClient) EXPECT() *MockTestServiceClient_Expecter

+ func (_m *MockTestServiceClient) ServerStream(ctx context.Context, in *testproto.Msg, opts ...grpc.CallOption) (testproto.TestService_ServerStreamClient, error)

+ func (_m *MockTestServiceClient) Unary(ctx context.Context, in *testproto.Msg, opts ...grpc.CallOption) (*testproto.Msg, error)

+ type MockTestServiceClient_BidiStream_Call struct

+ func (_c *MockTestServiceClient_BidiStream_Call) Return(_a0 testproto.TestService_BidiStreamClient, _a1 error) *MockTestServiceClient_BidiStream_Call

+ func (_c *MockTestServiceClient_BidiStream_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *MockTestServiceClient_BidiStream_Call

+ func (_c *MockTestServiceClient_BidiStream_Call) RunAndReturn(...) *MockTestServiceClient_BidiStream_Call

+ type MockTestServiceClient_ClientStream_Call struct

+ func (_c *MockTestServiceClient_ClientStream_Call) Return(_a0 testproto.TestService_ClientStreamClient, _a1 error) *MockTestServiceClient_ClientStream_Call

+ func (_c *MockTestServiceClient_ClientStream_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *MockTestServiceClient_ClientStream_Call

+ func (_c *MockTestServiceClient_ClientStream_Call) RunAndReturn(...) *MockTestServiceClient_ClientStream_Call

+ type MockTestServiceClient_Expecter struct

+ func (_e *MockTestServiceClient_Expecter) BidiStream(ctx interface{}, opts ...interface{}) *MockTestServiceClient_BidiStream_Call

+ func (_e *MockTestServiceClient_Expecter) ClientStream(ctx interface{}, opts ...interface{}) *MockTestServiceClient_ClientStream_Call

+ func (_e *MockTestServiceClient_Expecter) ServerStream(ctx interface{}, in interface{}, opts ...interface{}) *MockTestServiceClient_ServerStream_Call

+ func (_e *MockTestServiceClient_Expecter) Unary(ctx interface{}, in interface{}, opts ...interface{}) *MockTestServiceClient_Unary_Call

+ type MockTestServiceClient_ServerStream_Call struct

+ func (_c *MockTestServiceClient_ServerStream_Call) Return(_a0 testproto.TestService_ServerStreamClient, _a1 error) *MockTestServiceClient_ServerStream_Call

+ func (_c *MockTestServiceClient_ServerStream_Call) Run(run func(ctx context.Context, in *testproto.Msg, opts ...grpc.CallOption)) *MockTestServiceClient_ServerStream_Call

+ func (_c *MockTestServiceClient_ServerStream_Call) RunAndReturn(...) *MockTestServiceClient_ServerStream_Call

+ type MockTestServiceClient_Unary_Call struct

+ func (_c *MockTestServiceClient_Unary_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestServiceClient_Unary_Call

+ func (_c *MockTestServiceClient_Unary_Call) Run(run func(ctx context.Context, in *testproto.Msg, opts ...grpc.CallOption)) *MockTestServiceClient_Unary_Call

+ func (_c *MockTestServiceClient_Unary_Call) RunAndReturn(...) *MockTestServiceClient_Unary_Call

+ type MockTestServiceServer struct

+ func NewMockTestServiceServer(t interface{ ... }) *MockTestServiceServer

+ func (_m *MockTestServiceServer) BidiStream(_a0 testproto.TestService_BidiStreamServer) error

+ func (_m *MockTestServiceServer) ClientStream(_a0 testproto.TestService_ClientStreamServer) error

+ func (_m *MockTestServiceServer) EXPECT() *MockTestServiceServer_Expecter

+ func (_m *MockTestServiceServer) ServerStream(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamServer) error

+ func (_m *MockTestServiceServer) Unary(_a0 context.Context, _a1 *testproto.Msg) (*testproto.Msg, error)

+ type MockTestServiceServer_BidiStream_Call struct

+ func (_c *MockTestServiceServer_BidiStream_Call) Return(_a0 error) *MockTestServiceServer_BidiStream_Call

+ func (_c *MockTestServiceServer_BidiStream_Call) Run(run func(_a0 testproto.TestService_BidiStreamServer)) *MockTestServiceServer_BidiStream_Call

+ func (_c *MockTestServiceServer_BidiStream_Call) RunAndReturn(run func(testproto.TestService_BidiStreamServer) error) *MockTestServiceServer_BidiStream_Call

+ type MockTestServiceServer_ClientStream_Call struct

+ func (_c *MockTestServiceServer_ClientStream_Call) Return(_a0 error) *MockTestServiceServer_ClientStream_Call

+ func (_c *MockTestServiceServer_ClientStream_Call) Run(run func(_a0 testproto.TestService_ClientStreamServer)) *MockTestServiceServer_ClientStream_Call

+ func (_c *MockTestServiceServer_ClientStream_Call) RunAndReturn(run func(testproto.TestService_ClientStreamServer) error) *MockTestServiceServer_ClientStream_Call

+ type MockTestServiceServer_Expecter struct

+ func (_e *MockTestServiceServer_Expecter) BidiStream(_a0 interface{}) *MockTestServiceServer_BidiStream_Call

+ func (_e *MockTestServiceServer_Expecter) ClientStream(_a0 interface{}) *MockTestServiceServer_ClientStream_Call

+ func (_e *MockTestServiceServer_Expecter) ServerStream(_a0 interface{}, _a1 interface{}) *MockTestServiceServer_ServerStream_Call

+ func (_e *MockTestServiceServer_Expecter) Unary(_a0 interface{}, _a1 interface{}) *MockTestServiceServer_Unary_Call

+ type MockTestServiceServer_ServerStream_Call struct

+ func (_c *MockTestServiceServer_ServerStream_Call) Return(_a0 error) *MockTestServiceServer_ServerStream_Call

+ func (_c *MockTestServiceServer_ServerStream_Call) Run(run func(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamServer)) *MockTestServiceServer_ServerStream_Call

+ func (_c *MockTestServiceServer_ServerStream_Call) RunAndReturn(run func(*testproto.Msg, testproto.TestService_ServerStreamServer) error) *MockTestServiceServer_ServerStream_Call

+ type MockTestServiceServer_Unary_Call struct

+ func (_c *MockTestServiceServer_Unary_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestServiceServer_Unary_Call

+ func (_c *MockTestServiceServer_Unary_Call) Run(run func(_a0 context.Context, _a1 *testproto.Msg)) *MockTestServiceServer_Unary_Call

+ func (_c *MockTestServiceServer_Unary_Call) RunAndReturn(run func(context.Context, *testproto.Msg) (*testproto.Msg, error)) *MockTestServiceServer_Unary_Call

+ type MockTestService_BidiStreamClient struct

+ func NewMockTestService_BidiStreamClient(t interface{ ... }) *MockTestService_BidiStreamClient

+ func (_m *MockTestService_BidiStreamClient) CloseSend() error

+ func (_m *MockTestService_BidiStreamClient) Context() context.Context

+ func (_m *MockTestService_BidiStreamClient) EXPECT() *MockTestService_BidiStreamClient_Expecter

+ func (_m *MockTestService_BidiStreamClient) Header() (metadata.MD, error)

+ func (_m *MockTestService_BidiStreamClient) Recv() (*testproto.Msg, error)

+ func (_m *MockTestService_BidiStreamClient) RecvMsg(m interface{}) error

+ func (_m *MockTestService_BidiStreamClient) Send(_a0 *testproto.Msg) error

+ func (_m *MockTestService_BidiStreamClient) SendMsg(m interface{}) error

+ func (_m *MockTestService_BidiStreamClient) Trailer() metadata.MD

+ type MockTestService_BidiStreamClient_CloseSend_Call struct

+ func (_c *MockTestService_BidiStreamClient_CloseSend_Call) Return(_a0 error) *MockTestService_BidiStreamClient_CloseSend_Call

+ func (_c *MockTestService_BidiStreamClient_CloseSend_Call) Run(run func()) *MockTestService_BidiStreamClient_CloseSend_Call

+ func (_c *MockTestService_BidiStreamClient_CloseSend_Call) RunAndReturn(run func() error) *MockTestService_BidiStreamClient_CloseSend_Call

+ type MockTestService_BidiStreamClient_Context_Call struct

+ func (_c *MockTestService_BidiStreamClient_Context_Call) Return(_a0 context.Context) *MockTestService_BidiStreamClient_Context_Call

+ func (_c *MockTestService_BidiStreamClient_Context_Call) Run(run func()) *MockTestService_BidiStreamClient_Context_Call

+ func (_c *MockTestService_BidiStreamClient_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_BidiStreamClient_Context_Call

+ type MockTestService_BidiStreamClient_Expecter struct

+ func (_e *MockTestService_BidiStreamClient_Expecter) CloseSend() *MockTestService_BidiStreamClient_CloseSend_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) Context() *MockTestService_BidiStreamClient_Context_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) Header() *MockTestService_BidiStreamClient_Header_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) Recv() *MockTestService_BidiStreamClient_Recv_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) RecvMsg(m interface{}) *MockTestService_BidiStreamClient_RecvMsg_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) Send(_a0 interface{}) *MockTestService_BidiStreamClient_Send_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) SendMsg(m interface{}) *MockTestService_BidiStreamClient_SendMsg_Call

+ func (_e *MockTestService_BidiStreamClient_Expecter) Trailer() *MockTestService_BidiStreamClient_Trailer_Call

+ type MockTestService_BidiStreamClient_Header_Call struct

+ func (_c *MockTestService_BidiStreamClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *MockTestService_BidiStreamClient_Header_Call

+ func (_c *MockTestService_BidiStreamClient_Header_Call) Run(run func()) *MockTestService_BidiStreamClient_Header_Call

+ func (_c *MockTestService_BidiStreamClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *MockTestService_BidiStreamClient_Header_Call

+ type MockTestService_BidiStreamClient_RecvMsg_Call struct

+ func (_c *MockTestService_BidiStreamClient_RecvMsg_Call) Return(_a0 error) *MockTestService_BidiStreamClient_RecvMsg_Call

+ func (_c *MockTestService_BidiStreamClient_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_BidiStreamClient_RecvMsg_Call

+ func (_c *MockTestService_BidiStreamClient_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_BidiStreamClient_RecvMsg_Call

+ type MockTestService_BidiStreamClient_Recv_Call struct

+ func (_c *MockTestService_BidiStreamClient_Recv_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestService_BidiStreamClient_Recv_Call

+ func (_c *MockTestService_BidiStreamClient_Recv_Call) Run(run func()) *MockTestService_BidiStreamClient_Recv_Call

+ func (_c *MockTestService_BidiStreamClient_Recv_Call) RunAndReturn(run func() (*testproto.Msg, error)) *MockTestService_BidiStreamClient_Recv_Call

+ type MockTestService_BidiStreamClient_SendMsg_Call struct

+ func (_c *MockTestService_BidiStreamClient_SendMsg_Call) Return(_a0 error) *MockTestService_BidiStreamClient_SendMsg_Call

+ func (_c *MockTestService_BidiStreamClient_SendMsg_Call) Run(run func(m interface{})) *MockTestService_BidiStreamClient_SendMsg_Call

+ func (_c *MockTestService_BidiStreamClient_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_BidiStreamClient_SendMsg_Call

+ type MockTestService_BidiStreamClient_Send_Call struct

+ func (_c *MockTestService_BidiStreamClient_Send_Call) Return(_a0 error) *MockTestService_BidiStreamClient_Send_Call

+ func (_c *MockTestService_BidiStreamClient_Send_Call) Run(run func(_a0 *testproto.Msg)) *MockTestService_BidiStreamClient_Send_Call

+ func (_c *MockTestService_BidiStreamClient_Send_Call) RunAndReturn(run func(*testproto.Msg) error) *MockTestService_BidiStreamClient_Send_Call

+ type MockTestService_BidiStreamClient_Trailer_Call struct

+ func (_c *MockTestService_BidiStreamClient_Trailer_Call) Return(_a0 metadata.MD) *MockTestService_BidiStreamClient_Trailer_Call

+ func (_c *MockTestService_BidiStreamClient_Trailer_Call) Run(run func()) *MockTestService_BidiStreamClient_Trailer_Call

+ func (_c *MockTestService_BidiStreamClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *MockTestService_BidiStreamClient_Trailer_Call

+ type MockTestService_BidiStreamServer struct

+ func NewMockTestService_BidiStreamServer(t interface{ ... }) *MockTestService_BidiStreamServer

+ func (_m *MockTestService_BidiStreamServer) Context() context.Context

+ func (_m *MockTestService_BidiStreamServer) EXPECT() *MockTestService_BidiStreamServer_Expecter

+ func (_m *MockTestService_BidiStreamServer) Recv() (*testproto.Msg, error)

+ func (_m *MockTestService_BidiStreamServer) RecvMsg(m interface{}) error

+ func (_m *MockTestService_BidiStreamServer) Send(_a0 *testproto.Msg) error

+ func (_m *MockTestService_BidiStreamServer) SendHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_BidiStreamServer) SendMsg(m interface{}) error

+ func (_m *MockTestService_BidiStreamServer) SetHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_BidiStreamServer) SetTrailer(_a0 metadata.MD)

+ type MockTestService_BidiStreamServer_Context_Call struct

+ func (_c *MockTestService_BidiStreamServer_Context_Call) Return(_a0 context.Context) *MockTestService_BidiStreamServer_Context_Call

+ func (_c *MockTestService_BidiStreamServer_Context_Call) Run(run func()) *MockTestService_BidiStreamServer_Context_Call

+ func (_c *MockTestService_BidiStreamServer_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_BidiStreamServer_Context_Call

+ type MockTestService_BidiStreamServer_Expecter struct

+ func (_e *MockTestService_BidiStreamServer_Expecter) Context() *MockTestService_BidiStreamServer_Context_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) Recv() *MockTestService_BidiStreamServer_Recv_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) RecvMsg(m interface{}) *MockTestService_BidiStreamServer_RecvMsg_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) Send(_a0 interface{}) *MockTestService_BidiStreamServer_Send_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) SendHeader(_a0 interface{}) *MockTestService_BidiStreamServer_SendHeader_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) SendMsg(m interface{}) *MockTestService_BidiStreamServer_SendMsg_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) SetHeader(_a0 interface{}) *MockTestService_BidiStreamServer_SetHeader_Call

+ func (_e *MockTestService_BidiStreamServer_Expecter) SetTrailer(_a0 interface{}) *MockTestService_BidiStreamServer_SetTrailer_Call

+ type MockTestService_BidiStreamServer_RecvMsg_Call struct

+ func (_c *MockTestService_BidiStreamServer_RecvMsg_Call) Return(_a0 error) *MockTestService_BidiStreamServer_RecvMsg_Call

+ func (_c *MockTestService_BidiStreamServer_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_BidiStreamServer_RecvMsg_Call

+ func (_c *MockTestService_BidiStreamServer_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_BidiStreamServer_RecvMsg_Call

+ type MockTestService_BidiStreamServer_Recv_Call struct

+ func (_c *MockTestService_BidiStreamServer_Recv_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestService_BidiStreamServer_Recv_Call

+ func (_c *MockTestService_BidiStreamServer_Recv_Call) Run(run func()) *MockTestService_BidiStreamServer_Recv_Call

+ func (_c *MockTestService_BidiStreamServer_Recv_Call) RunAndReturn(run func() (*testproto.Msg, error)) *MockTestService_BidiStreamServer_Recv_Call

+ type MockTestService_BidiStreamServer_SendHeader_Call struct

+ func (_c *MockTestService_BidiStreamServer_SendHeader_Call) Return(_a0 error) *MockTestService_BidiStreamServer_SendHeader_Call

+ func (_c *MockTestService_BidiStreamServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_BidiStreamServer_SendHeader_Call

+ func (_c *MockTestService_BidiStreamServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_BidiStreamServer_SendHeader_Call

+ type MockTestService_BidiStreamServer_SendMsg_Call struct

+ func (_c *MockTestService_BidiStreamServer_SendMsg_Call) Return(_a0 error) *MockTestService_BidiStreamServer_SendMsg_Call

+ func (_c *MockTestService_BidiStreamServer_SendMsg_Call) Run(run func(m interface{})) *MockTestService_BidiStreamServer_SendMsg_Call

+ func (_c *MockTestService_BidiStreamServer_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_BidiStreamServer_SendMsg_Call

+ type MockTestService_BidiStreamServer_Send_Call struct

+ func (_c *MockTestService_BidiStreamServer_Send_Call) Return(_a0 error) *MockTestService_BidiStreamServer_Send_Call

+ func (_c *MockTestService_BidiStreamServer_Send_Call) Run(run func(_a0 *testproto.Msg)) *MockTestService_BidiStreamServer_Send_Call

+ func (_c *MockTestService_BidiStreamServer_Send_Call) RunAndReturn(run func(*testproto.Msg) error) *MockTestService_BidiStreamServer_Send_Call

+ type MockTestService_BidiStreamServer_SetHeader_Call struct

+ func (_c *MockTestService_BidiStreamServer_SetHeader_Call) Return(_a0 error) *MockTestService_BidiStreamServer_SetHeader_Call

+ func (_c *MockTestService_BidiStreamServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_BidiStreamServer_SetHeader_Call

+ func (_c *MockTestService_BidiStreamServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_BidiStreamServer_SetHeader_Call

+ type MockTestService_BidiStreamServer_SetTrailer_Call struct

+ func (_c *MockTestService_BidiStreamServer_SetTrailer_Call) Return() *MockTestService_BidiStreamServer_SetTrailer_Call

+ func (_c *MockTestService_BidiStreamServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *MockTestService_BidiStreamServer_SetTrailer_Call

+ func (_c *MockTestService_BidiStreamServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *MockTestService_BidiStreamServer_SetTrailer_Call

+ type MockTestService_ClientStreamClient struct

+ func NewMockTestService_ClientStreamClient(t interface{ ... }) *MockTestService_ClientStreamClient

+ func (_m *MockTestService_ClientStreamClient) CloseAndRecv() (*testproto.Msg, error)

+ func (_m *MockTestService_ClientStreamClient) CloseSend() error

+ func (_m *MockTestService_ClientStreamClient) Context() context.Context

+ func (_m *MockTestService_ClientStreamClient) EXPECT() *MockTestService_ClientStreamClient_Expecter

+ func (_m *MockTestService_ClientStreamClient) Header() (metadata.MD, error)

+ func (_m *MockTestService_ClientStreamClient) RecvMsg(m interface{}) error

+ func (_m *MockTestService_ClientStreamClient) Send(_a0 *testproto.Msg) error

+ func (_m *MockTestService_ClientStreamClient) SendMsg(m interface{}) error

+ func (_m *MockTestService_ClientStreamClient) Trailer() metadata.MD

+ type MockTestService_ClientStreamClient_CloseAndRecv_Call struct

+ func (_c *MockTestService_ClientStreamClient_CloseAndRecv_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestService_ClientStreamClient_CloseAndRecv_Call

+ func (_c *MockTestService_ClientStreamClient_CloseAndRecv_Call) Run(run func()) *MockTestService_ClientStreamClient_CloseAndRecv_Call

+ func (_c *MockTestService_ClientStreamClient_CloseAndRecv_Call) RunAndReturn(run func() (*testproto.Msg, error)) *MockTestService_ClientStreamClient_CloseAndRecv_Call

+ type MockTestService_ClientStreamClient_CloseSend_Call struct

+ func (_c *MockTestService_ClientStreamClient_CloseSend_Call) Return(_a0 error) *MockTestService_ClientStreamClient_CloseSend_Call

+ func (_c *MockTestService_ClientStreamClient_CloseSend_Call) Run(run func()) *MockTestService_ClientStreamClient_CloseSend_Call

+ func (_c *MockTestService_ClientStreamClient_CloseSend_Call) RunAndReturn(run func() error) *MockTestService_ClientStreamClient_CloseSend_Call

+ type MockTestService_ClientStreamClient_Context_Call struct

+ func (_c *MockTestService_ClientStreamClient_Context_Call) Return(_a0 context.Context) *MockTestService_ClientStreamClient_Context_Call

+ func (_c *MockTestService_ClientStreamClient_Context_Call) Run(run func()) *MockTestService_ClientStreamClient_Context_Call

+ func (_c *MockTestService_ClientStreamClient_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_ClientStreamClient_Context_Call

+ type MockTestService_ClientStreamClient_Expecter struct

+ func (_e *MockTestService_ClientStreamClient_Expecter) CloseAndRecv() *MockTestService_ClientStreamClient_CloseAndRecv_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) CloseSend() *MockTestService_ClientStreamClient_CloseSend_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) Context() *MockTestService_ClientStreamClient_Context_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) Header() *MockTestService_ClientStreamClient_Header_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) RecvMsg(m interface{}) *MockTestService_ClientStreamClient_RecvMsg_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) Send(_a0 interface{}) *MockTestService_ClientStreamClient_Send_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) SendMsg(m interface{}) *MockTestService_ClientStreamClient_SendMsg_Call

+ func (_e *MockTestService_ClientStreamClient_Expecter) Trailer() *MockTestService_ClientStreamClient_Trailer_Call

+ type MockTestService_ClientStreamClient_Header_Call struct

+ func (_c *MockTestService_ClientStreamClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *MockTestService_ClientStreamClient_Header_Call

+ func (_c *MockTestService_ClientStreamClient_Header_Call) Run(run func()) *MockTestService_ClientStreamClient_Header_Call

+ func (_c *MockTestService_ClientStreamClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *MockTestService_ClientStreamClient_Header_Call

+ type MockTestService_ClientStreamClient_RecvMsg_Call struct

+ func (_c *MockTestService_ClientStreamClient_RecvMsg_Call) Return(_a0 error) *MockTestService_ClientStreamClient_RecvMsg_Call

+ func (_c *MockTestService_ClientStreamClient_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_ClientStreamClient_RecvMsg_Call

+ func (_c *MockTestService_ClientStreamClient_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ClientStreamClient_RecvMsg_Call

+ type MockTestService_ClientStreamClient_SendMsg_Call struct

+ func (_c *MockTestService_ClientStreamClient_SendMsg_Call) Return(_a0 error) *MockTestService_ClientStreamClient_SendMsg_Call

+ func (_c *MockTestService_ClientStreamClient_SendMsg_Call) Run(run func(m interface{})) *MockTestService_ClientStreamClient_SendMsg_Call

+ func (_c *MockTestService_ClientStreamClient_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ClientStreamClient_SendMsg_Call

+ type MockTestService_ClientStreamClient_Send_Call struct

+ func (_c *MockTestService_ClientStreamClient_Send_Call) Return(_a0 error) *MockTestService_ClientStreamClient_Send_Call

+ func (_c *MockTestService_ClientStreamClient_Send_Call) Run(run func(_a0 *testproto.Msg)) *MockTestService_ClientStreamClient_Send_Call

+ func (_c *MockTestService_ClientStreamClient_Send_Call) RunAndReturn(run func(*testproto.Msg) error) *MockTestService_ClientStreamClient_Send_Call

+ type MockTestService_ClientStreamClient_Trailer_Call struct

+ func (_c *MockTestService_ClientStreamClient_Trailer_Call) Return(_a0 metadata.MD) *MockTestService_ClientStreamClient_Trailer_Call

+ func (_c *MockTestService_ClientStreamClient_Trailer_Call) Run(run func()) *MockTestService_ClientStreamClient_Trailer_Call

+ func (_c *MockTestService_ClientStreamClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *MockTestService_ClientStreamClient_Trailer_Call

+ type MockTestService_ClientStreamServer struct

+ func NewMockTestService_ClientStreamServer(t interface{ ... }) *MockTestService_ClientStreamServer

+ func (_m *MockTestService_ClientStreamServer) Context() context.Context

+ func (_m *MockTestService_ClientStreamServer) EXPECT() *MockTestService_ClientStreamServer_Expecter

+ func (_m *MockTestService_ClientStreamServer) Recv() (*testproto.Msg, error)

+ func (_m *MockTestService_ClientStreamServer) RecvMsg(m interface{}) error

+ func (_m *MockTestService_ClientStreamServer) SendAndClose(_a0 *testproto.Msg) error

+ func (_m *MockTestService_ClientStreamServer) SendHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_ClientStreamServer) SendMsg(m interface{}) error

+ func (_m *MockTestService_ClientStreamServer) SetHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_ClientStreamServer) SetTrailer(_a0 metadata.MD)

+ type MockTestService_ClientStreamServer_Context_Call struct

+ func (_c *MockTestService_ClientStreamServer_Context_Call) Return(_a0 context.Context) *MockTestService_ClientStreamServer_Context_Call

+ func (_c *MockTestService_ClientStreamServer_Context_Call) Run(run func()) *MockTestService_ClientStreamServer_Context_Call

+ func (_c *MockTestService_ClientStreamServer_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_ClientStreamServer_Context_Call

+ type MockTestService_ClientStreamServer_Expecter struct

+ func (_e *MockTestService_ClientStreamServer_Expecter) Context() *MockTestService_ClientStreamServer_Context_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) Recv() *MockTestService_ClientStreamServer_Recv_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) RecvMsg(m interface{}) *MockTestService_ClientStreamServer_RecvMsg_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) SendAndClose(_a0 interface{}) *MockTestService_ClientStreamServer_SendAndClose_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) SendHeader(_a0 interface{}) *MockTestService_ClientStreamServer_SendHeader_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) SendMsg(m interface{}) *MockTestService_ClientStreamServer_SendMsg_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) SetHeader(_a0 interface{}) *MockTestService_ClientStreamServer_SetHeader_Call

+ func (_e *MockTestService_ClientStreamServer_Expecter) SetTrailer(_a0 interface{}) *MockTestService_ClientStreamServer_SetTrailer_Call

+ type MockTestService_ClientStreamServer_RecvMsg_Call struct

+ func (_c *MockTestService_ClientStreamServer_RecvMsg_Call) Return(_a0 error) *MockTestService_ClientStreamServer_RecvMsg_Call

+ func (_c *MockTestService_ClientStreamServer_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_ClientStreamServer_RecvMsg_Call

+ func (_c *MockTestService_ClientStreamServer_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ClientStreamServer_RecvMsg_Call

+ type MockTestService_ClientStreamServer_Recv_Call struct

+ func (_c *MockTestService_ClientStreamServer_Recv_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestService_ClientStreamServer_Recv_Call

+ func (_c *MockTestService_ClientStreamServer_Recv_Call) Run(run func()) *MockTestService_ClientStreamServer_Recv_Call

+ func (_c *MockTestService_ClientStreamServer_Recv_Call) RunAndReturn(run func() (*testproto.Msg, error)) *MockTestService_ClientStreamServer_Recv_Call

+ type MockTestService_ClientStreamServer_SendAndClose_Call struct

+ func (_c *MockTestService_ClientStreamServer_SendAndClose_Call) Return(_a0 error) *MockTestService_ClientStreamServer_SendAndClose_Call

+ func (_c *MockTestService_ClientStreamServer_SendAndClose_Call) Run(run func(_a0 *testproto.Msg)) *MockTestService_ClientStreamServer_SendAndClose_Call

+ func (_c *MockTestService_ClientStreamServer_SendAndClose_Call) RunAndReturn(run func(*testproto.Msg) error) *MockTestService_ClientStreamServer_SendAndClose_Call

+ type MockTestService_ClientStreamServer_SendHeader_Call struct

+ func (_c *MockTestService_ClientStreamServer_SendHeader_Call) Return(_a0 error) *MockTestService_ClientStreamServer_SendHeader_Call

+ func (_c *MockTestService_ClientStreamServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ClientStreamServer_SendHeader_Call

+ func (_c *MockTestService_ClientStreamServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_ClientStreamServer_SendHeader_Call

+ type MockTestService_ClientStreamServer_SendMsg_Call struct

+ func (_c *MockTestService_ClientStreamServer_SendMsg_Call) Return(_a0 error) *MockTestService_ClientStreamServer_SendMsg_Call

+ func (_c *MockTestService_ClientStreamServer_SendMsg_Call) Run(run func(m interface{})) *MockTestService_ClientStreamServer_SendMsg_Call

+ func (_c *MockTestService_ClientStreamServer_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ClientStreamServer_SendMsg_Call

+ type MockTestService_ClientStreamServer_SetHeader_Call struct

+ func (_c *MockTestService_ClientStreamServer_SetHeader_Call) Return(_a0 error) *MockTestService_ClientStreamServer_SetHeader_Call

+ func (_c *MockTestService_ClientStreamServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ClientStreamServer_SetHeader_Call

+ func (_c *MockTestService_ClientStreamServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_ClientStreamServer_SetHeader_Call

+ type MockTestService_ClientStreamServer_SetTrailer_Call struct

+ func (_c *MockTestService_ClientStreamServer_SetTrailer_Call) Return() *MockTestService_ClientStreamServer_SetTrailer_Call

+ func (_c *MockTestService_ClientStreamServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ClientStreamServer_SetTrailer_Call

+ func (_c *MockTestService_ClientStreamServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *MockTestService_ClientStreamServer_SetTrailer_Call

+ type MockTestService_ServerStreamClient struct

+ func NewMockTestService_ServerStreamClient(t interface{ ... }) *MockTestService_ServerStreamClient

+ func (_m *MockTestService_ServerStreamClient) CloseSend() error

+ func (_m *MockTestService_ServerStreamClient) Context() context.Context

+ func (_m *MockTestService_ServerStreamClient) EXPECT() *MockTestService_ServerStreamClient_Expecter

+ func (_m *MockTestService_ServerStreamClient) Header() (metadata.MD, error)

+ func (_m *MockTestService_ServerStreamClient) Recv() (*testproto.Msg, error)

+ func (_m *MockTestService_ServerStreamClient) RecvMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamClient) SendMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamClient) Trailer() metadata.MD

+ type MockTestService_ServerStreamClient_CloseSend_Call struct

+ func (_c *MockTestService_ServerStreamClient_CloseSend_Call) Return(_a0 error) *MockTestService_ServerStreamClient_CloseSend_Call

+ func (_c *MockTestService_ServerStreamClient_CloseSend_Call) Run(run func()) *MockTestService_ServerStreamClient_CloseSend_Call

+ func (_c *MockTestService_ServerStreamClient_CloseSend_Call) RunAndReturn(run func() error) *MockTestService_ServerStreamClient_CloseSend_Call

+ type MockTestService_ServerStreamClient_Context_Call struct

+ func (_c *MockTestService_ServerStreamClient_Context_Call) Return(_a0 context.Context) *MockTestService_ServerStreamClient_Context_Call

+ func (_c *MockTestService_ServerStreamClient_Context_Call) Run(run func()) *MockTestService_ServerStreamClient_Context_Call

+ func (_c *MockTestService_ServerStreamClient_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_ServerStreamClient_Context_Call

+ type MockTestService_ServerStreamClient_Expecter struct

+ func (_e *MockTestService_ServerStreamClient_Expecter) CloseSend() *MockTestService_ServerStreamClient_CloseSend_Call

+ func (_e *MockTestService_ServerStreamClient_Expecter) Context() *MockTestService_ServerStreamClient_Context_Call

+ func (_e *MockTestService_ServerStreamClient_Expecter) Header() *MockTestService_ServerStreamClient_Header_Call

+ func (_e *MockTestService_ServerStreamClient_Expecter) Recv() *MockTestService_ServerStreamClient_Recv_Call

+ func (_e *MockTestService_ServerStreamClient_Expecter) RecvMsg(m interface{}) *MockTestService_ServerStreamClient_RecvMsg_Call

+ func (_e *MockTestService_ServerStreamClient_Expecter) SendMsg(m interface{}) *MockTestService_ServerStreamClient_SendMsg_Call

+ func (_e *MockTestService_ServerStreamClient_Expecter) Trailer() *MockTestService_ServerStreamClient_Trailer_Call

+ type MockTestService_ServerStreamClient_Header_Call struct

+ func (_c *MockTestService_ServerStreamClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *MockTestService_ServerStreamClient_Header_Call

+ func (_c *MockTestService_ServerStreamClient_Header_Call) Run(run func()) *MockTestService_ServerStreamClient_Header_Call

+ func (_c *MockTestService_ServerStreamClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *MockTestService_ServerStreamClient_Header_Call

+ type MockTestService_ServerStreamClient_RecvMsg_Call struct

+ func (_c *MockTestService_ServerStreamClient_RecvMsg_Call) Return(_a0 error) *MockTestService_ServerStreamClient_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamClient_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamClient_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamClient_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamClient_RecvMsg_Call

+ type MockTestService_ServerStreamClient_Recv_Call struct

+ func (_c *MockTestService_ServerStreamClient_Recv_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestService_ServerStreamClient_Recv_Call

+ func (_c *MockTestService_ServerStreamClient_Recv_Call) Run(run func()) *MockTestService_ServerStreamClient_Recv_Call

+ func (_c *MockTestService_ServerStreamClient_Recv_Call) RunAndReturn(run func() (*testproto.Msg, error)) *MockTestService_ServerStreamClient_Recv_Call

+ type MockTestService_ServerStreamClient_SendMsg_Call struct

+ func (_c *MockTestService_ServerStreamClient_SendMsg_Call) Return(_a0 error) *MockTestService_ServerStreamClient_SendMsg_Call

+ func (_c *MockTestService_ServerStreamClient_SendMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamClient_SendMsg_Call

+ func (_c *MockTestService_ServerStreamClient_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamClient_SendMsg_Call

+ type MockTestService_ServerStreamClient_Trailer_Call struct

+ func (_c *MockTestService_ServerStreamClient_Trailer_Call) Return(_a0 metadata.MD) *MockTestService_ServerStreamClient_Trailer_Call

+ func (_c *MockTestService_ServerStreamClient_Trailer_Call) Run(run func()) *MockTestService_ServerStreamClient_Trailer_Call

+ func (_c *MockTestService_ServerStreamClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *MockTestService_ServerStreamClient_Trailer_Call

+ type MockTestService_ServerStreamServer struct

+ func NewMockTestService_ServerStreamServer(t interface{ ... }) *MockTestService_ServerStreamServer

+ func (_m *MockTestService_ServerStreamServer) Context() context.Context

+ func (_m *MockTestService_ServerStreamServer) EXPECT() *MockTestService_ServerStreamServer_Expecter

+ func (_m *MockTestService_ServerStreamServer) RecvMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamServer) Send(_a0 *testproto.Msg) error

+ func (_m *MockTestService_ServerStreamServer) SendHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_ServerStreamServer) SendMsg(m interface{}) error

+ func (_m *MockTestService_ServerStreamServer) SetHeader(_a0 metadata.MD) error

+ func (_m *MockTestService_ServerStreamServer) SetTrailer(_a0 metadata.MD)

+ type MockTestService_ServerStreamServer_Context_Call struct

+ func (_c *MockTestService_ServerStreamServer_Context_Call) Return(_a0 context.Context) *MockTestService_ServerStreamServer_Context_Call

+ func (_c *MockTestService_ServerStreamServer_Context_Call) Run(run func()) *MockTestService_ServerStreamServer_Context_Call

+ func (_c *MockTestService_ServerStreamServer_Context_Call) RunAndReturn(run func() context.Context) *MockTestService_ServerStreamServer_Context_Call

+ type MockTestService_ServerStreamServer_Expecter struct

+ func (_e *MockTestService_ServerStreamServer_Expecter) Context() *MockTestService_ServerStreamServer_Context_Call

+ func (_e *MockTestService_ServerStreamServer_Expecter) RecvMsg(m interface{}) *MockTestService_ServerStreamServer_RecvMsg_Call

+ func (_e *MockTestService_ServerStreamServer_Expecter) Send(_a0 interface{}) *MockTestService_ServerStreamServer_Send_Call

+ func (_e *MockTestService_ServerStreamServer_Expecter) SendHeader(_a0 interface{}) *MockTestService_ServerStreamServer_SendHeader_Call

+ func (_e *MockTestService_ServerStreamServer_Expecter) SendMsg(m interface{}) *MockTestService_ServerStreamServer_SendMsg_Call

+ func (_e *MockTestService_ServerStreamServer_Expecter) SetHeader(_a0 interface{}) *MockTestService_ServerStreamServer_SetHeader_Call

+ func (_e *MockTestService_ServerStreamServer_Expecter) SetTrailer(_a0 interface{}) *MockTestService_ServerStreamServer_SetTrailer_Call

+ type MockTestService_ServerStreamServer_RecvMsg_Call struct

+ func (_c *MockTestService_ServerStreamServer_RecvMsg_Call) Return(_a0 error) *MockTestService_ServerStreamServer_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamServer_RecvMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamServer_RecvMsg_Call

+ func (_c *MockTestService_ServerStreamServer_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamServer_RecvMsg_Call

+ type MockTestService_ServerStreamServer_SendHeader_Call struct

+ func (_c *MockTestService_ServerStreamServer_SendHeader_Call) Return(_a0 error) *MockTestService_ServerStreamServer_SendHeader_Call

+ func (_c *MockTestService_ServerStreamServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ServerStreamServer_SendHeader_Call

+ func (_c *MockTestService_ServerStreamServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_ServerStreamServer_SendHeader_Call

+ type MockTestService_ServerStreamServer_SendMsg_Call struct

+ func (_c *MockTestService_ServerStreamServer_SendMsg_Call) Return(_a0 error) *MockTestService_ServerStreamServer_SendMsg_Call

+ func (_c *MockTestService_ServerStreamServer_SendMsg_Call) Run(run func(m interface{})) *MockTestService_ServerStreamServer_SendMsg_Call

+ func (_c *MockTestService_ServerStreamServer_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockTestService_ServerStreamServer_SendMsg_Call

+ type MockTestService_ServerStreamServer_Send_Call struct

+ func (_c *MockTestService_ServerStreamServer_Send_Call) Return(_a0 error) *MockTestService_ServerStreamServer_Send_Call

+ func (_c *MockTestService_ServerStreamServer_Send_Call) Run(run func(_a0 *testproto.Msg)) *MockTestService_ServerStreamServer_Send_Call

+ func (_c *MockTestService_ServerStreamServer_Send_Call) RunAndReturn(run func(*testproto.Msg) error) *MockTestService_ServerStreamServer_Send_Call

+ type MockTestService_ServerStreamServer_SetHeader_Call struct

+ func (_c *MockTestService_ServerStreamServer_SetHeader_Call) Return(_a0 error) *MockTestService_ServerStreamServer_SetHeader_Call

+ func (_c *MockTestService_ServerStreamServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ServerStreamServer_SetHeader_Call

+ func (_c *MockTestService_ServerStreamServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockTestService_ServerStreamServer_SetHeader_Call

+ type MockTestService_ServerStreamServer_SetTrailer_Call struct

+ func (_c *MockTestService_ServerStreamServer_SetTrailer_Call) Return() *MockTestService_ServerStreamServer_SetTrailer_Call

+ func (_c *MockTestService_ServerStreamServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *MockTestService_ServerStreamServer_SetTrailer_Call

+ func (_c *MockTestService_ServerStreamServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *MockTestService_ServerStreamServer_SetTrailer_Call

+ type MockUnsafeTestServiceServer struct

+ func NewMockUnsafeTestServiceServer(t interface{ ... }) *MockUnsafeTestServiceServer

+ func (_m *MockUnsafeTestServiceServer) EXPECT() *MockUnsafeTestServiceServer_Expecter

+ type MockUnsafeTestServiceServer_Expecter struct

+ type MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call struct

+ func (_c *MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call) Return() *MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call

+ func (_c *MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call) Run(run func()) *MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call

+ func (_c *MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call) RunAndReturn(run func()) *MockUnsafeTestServiceServer_mustEmbedUnimplementedTestServiceServer_Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL