public async stt::Task ListActiveBreakpointsRequestObjectAsync()
        {
            moq::Mock <Controller2.Controller2Client> mockGrpcClient = new moq::Mock <Controller2.Controller2Client>(moq::MockBehavior.Strict);
            ListActiveBreakpointsRequest request = new ListActiveBreakpointsRequest
            {
                DebuggeeId       = "debuggee_id454a924a",
                WaitToken        = "wait_tokencb600154",
                SuccessOnTimeout = false,
            };
            ListActiveBreakpointsResponse expectedResponse = new ListActiveBreakpointsResponse
            {
                Breakpoints   = { new Breakpoint(), },
                NextWaitToken = "next_wait_token2855eb7e",
                WaitExpired   = false,
            };

            mockGrpcClient.Setup(x => x.ListActiveBreakpointsAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <ListActiveBreakpointsResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            Controller2Client             client = new Controller2ClientImpl(mockGrpcClient.Object, null);
            ListActiveBreakpointsResponse responseCallSettings = await client.ListActiveBreakpointsAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            ListActiveBreakpointsResponse responseCancellationToken = await client.ListActiveBreakpointsAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public async Task RegisterDebuggeeAsync2()
        {
            Mock <Controller2.Controller2Client> mockGrpcClient = new Mock <Controller2.Controller2Client>(MockBehavior.Strict);
            RegisterDebuggeeRequest request = new RegisterDebuggeeRequest
            {
                Debuggee = new Debuggee(),
            };
            RegisterDebuggeeResponse expectedResponse = new RegisterDebuggeeResponse();

            mockGrpcClient.Setup(x => x.RegisterDebuggeeAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <RegisterDebuggeeResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            Controller2Client        client   = new Controller2ClientImpl(mockGrpcClient.Object, null);
            RegisterDebuggeeResponse response = await client.RegisterDebuggeeAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void RegisterDebuggee2()
        {
            Mock <Controller2.Controller2Client> mockGrpcClient = new Mock <Controller2.Controller2Client>(MockBehavior.Strict);
            RegisterDebuggeeRequest request = new RegisterDebuggeeRequest
            {
                Debuggee = new Debuggee(),
            };
            RegisterDebuggeeResponse expectedResponse = new RegisterDebuggeeResponse();

            mockGrpcClient.Setup(x => x.RegisterDebuggee(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            Controller2Client        client   = new Controller2ClientImpl(mockGrpcClient.Object, null);
            RegisterDebuggeeResponse response = client.RegisterDebuggee(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task UpdateActiveBreakpointAsync2()
        {
            Mock <Controller2.Controller2Client> mockGrpcClient = new Mock <Controller2.Controller2Client>(MockBehavior.Strict);
            UpdateActiveBreakpointRequest        request        = new UpdateActiveBreakpointRequest
            {
                DebuggeeId = "debuggeeId-997255898",
                Breakpoint = new Breakpoint(),
            };
            UpdateActiveBreakpointResponse expectedResponse = new UpdateActiveBreakpointResponse();

            mockGrpcClient.Setup(x => x.UpdateActiveBreakpointAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <UpdateActiveBreakpointResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            Controller2Client client = new Controller2ClientImpl(mockGrpcClient.Object, null);
            UpdateActiveBreakpointResponse response = await client.UpdateActiveBreakpointAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void UpdateActiveBreakpoint2()
        {
            Mock <Controller2.Controller2Client> mockGrpcClient = new Mock <Controller2.Controller2Client>(MockBehavior.Strict);
            UpdateActiveBreakpointRequest        request        = new UpdateActiveBreakpointRequest
            {
                DebuggeeId = "debuggeeId-997255898",
                Breakpoint = new Breakpoint(),
            };
            UpdateActiveBreakpointResponse expectedResponse = new UpdateActiveBreakpointResponse();

            mockGrpcClient.Setup(x => x.UpdateActiveBreakpoint(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            Controller2Client client = new Controller2ClientImpl(mockGrpcClient.Object, null);
            UpdateActiveBreakpointResponse response = client.UpdateActiveBreakpoint(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void UpdateActiveBreakpoint()
        {
            moq::Mock <Controller2.Controller2Client> mockGrpcClient = new moq::Mock <Controller2.Controller2Client>(moq::MockBehavior.Strict);
            UpdateActiveBreakpointRequest             request        = new UpdateActiveBreakpointRequest
            {
                DebuggeeId = "debuggee_id454a924a",
                Breakpoint = new Breakpoint(),
            };
            UpdateActiveBreakpointResponse expectedResponse = new UpdateActiveBreakpointResponse {
            };

            mockGrpcClient.Setup(x => x.UpdateActiveBreakpoint(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            Controller2Client client = new Controller2ClientImpl(mockGrpcClient.Object, null);
            UpdateActiveBreakpointResponse response = client.UpdateActiveBreakpoint(request.DebuggeeId, request.Breakpoint);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void RegisterDebuggee()
        {
            moq::Mock <Controller2.Controller2Client> mockGrpcClient = new moq::Mock <Controller2.Controller2Client>(moq::MockBehavior.Strict);
            RegisterDebuggeeRequest request = new RegisterDebuggeeRequest
            {
                Debuggee = new Debuggee(),
            };
            RegisterDebuggeeResponse expectedResponse = new RegisterDebuggeeResponse
            {
                Debuggee = new Debuggee(),
            };

            mockGrpcClient.Setup(x => x.RegisterDebuggee(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            Controller2Client        client   = new Controller2ClientImpl(mockGrpcClient.Object, null);
            RegisterDebuggeeResponse response = client.RegisterDebuggee(request.Debuggee);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task ListActiveBreakpointsAsync2()
        {
            Mock <Controller2.Controller2Client> mockGrpcClient = new Mock <Controller2.Controller2Client>(MockBehavior.Strict);
            ListActiveBreakpointsRequest         request        = new ListActiveBreakpointsRequest
            {
                DebuggeeId = "debuggeeId-997255898",
            };
            ListActiveBreakpointsResponse expectedResponse = new ListActiveBreakpointsResponse
            {
                NextWaitToken = "nextWaitToken1006864251",
                WaitExpired   = false,
            };

            mockGrpcClient.Setup(x => x.ListActiveBreakpointsAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <ListActiveBreakpointsResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            Controller2Client             client   = new Controller2ClientImpl(mockGrpcClient.Object, null);
            ListActiveBreakpointsResponse response = await client.ListActiveBreakpointsAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void ListActiveBreakpoints2()
        {
            Mock <Controller2.Controller2Client> mockGrpcClient = new Mock <Controller2.Controller2Client>(MockBehavior.Strict);
            ListActiveBreakpointsRequest         request        = new ListActiveBreakpointsRequest
            {
                DebuggeeId = "debuggeeId-997255898",
            };
            ListActiveBreakpointsResponse expectedResponse = new ListActiveBreakpointsResponse
            {
                NextWaitToken = "nextWaitToken1006864251",
                WaitExpired   = false,
            };

            mockGrpcClient.Setup(x => x.ListActiveBreakpoints(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            Controller2Client             client   = new Controller2ClientImpl(mockGrpcClient.Object, null);
            ListActiveBreakpointsResponse response = client.ListActiveBreakpoints(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task UpdateActiveBreakpointAsync()
        {
            moq::Mock <Controller2.Controller2Client> mockGrpcClient = new moq::Mock <Controller2.Controller2Client>(moq::MockBehavior.Strict);
            UpdateActiveBreakpointRequest             request        = new UpdateActiveBreakpointRequest
            {
                DebuggeeId = "debuggee_id454a924a",
                Breakpoint = new Breakpoint(),
            };
            UpdateActiveBreakpointResponse expectedResponse = new UpdateActiveBreakpointResponse {
            };

            mockGrpcClient.Setup(x => x.UpdateActiveBreakpointAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <UpdateActiveBreakpointResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            Controller2Client client = new Controller2ClientImpl(mockGrpcClient.Object, null);
            UpdateActiveBreakpointResponse responseCallSettings = await client.UpdateActiveBreakpointAsync(request.DebuggeeId, request.Breakpoint, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            UpdateActiveBreakpointResponse responseCancellationToken = await client.UpdateActiveBreakpointAsync(request.DebuggeeId, request.Breakpoint, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void ListActiveBreakpoints()
        {
            moq::Mock <Controller2.Controller2Client> mockGrpcClient = new moq::Mock <Controller2.Controller2Client>(moq::MockBehavior.Strict);
            ListActiveBreakpointsRequest request = new ListActiveBreakpointsRequest
            {
                DebuggeeId = "debuggee_id454a924a",
            };
            ListActiveBreakpointsResponse expectedResponse = new ListActiveBreakpointsResponse
            {
                Breakpoints   = { new Breakpoint(), },
                NextWaitToken = "next_wait_token2855eb7e",
                WaitExpired   = false,
            };

            mockGrpcClient.Setup(x => x.ListActiveBreakpoints(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            Controller2Client             client   = new Controller2ClientImpl(mockGrpcClient.Object, null);
            ListActiveBreakpointsResponse response = client.ListActiveBreakpoints(request.DebuggeeId);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task RegisterDebuggeeAsync()
        {
            moq::Mock <Controller2.Controller2Client> mockGrpcClient = new moq::Mock <Controller2.Controller2Client>(moq::MockBehavior.Strict);
            RegisterDebuggeeRequest request = new RegisterDebuggeeRequest
            {
                Debuggee = new Debuggee(),
            };
            RegisterDebuggeeResponse expectedResponse = new RegisterDebuggeeResponse
            {
                Debuggee = new Debuggee(),
            };

            mockGrpcClient.Setup(x => x.RegisterDebuggeeAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <RegisterDebuggeeResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            Controller2Client        client = new Controller2ClientImpl(mockGrpcClient.Object, null);
            RegisterDebuggeeResponse responseCallSettings = await client.RegisterDebuggeeAsync(request.Debuggee, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            RegisterDebuggeeResponse responseCancellationToken = await client.RegisterDebuggeeAsync(request.Debuggee, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }