public async stt::Task GetGameServerDeploymentRequestObjectAsync()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetGameServerDeploymentRequest request = new GetGameServerDeploymentRequest
            {
                GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
            };
            GameServerDeployment expectedResponse = new GameServerDeployment
            {
                GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
                CreateTime = new wkt::Timestamp(),
                UpdateTime = new wkt::Timestamp(),
                Labels     =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                Etag        = "etage8ad7218",
                Description = "description2cf9da67",
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void FetchDeploymentStateRequestObject()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            FetchDeploymentStateRequest request = new FetchDeploymentStateRequest
            {
                Name = "name1c9368b0",
            };
            FetchDeploymentStateResponse expectedResponse = new FetchDeploymentStateResponse
            {
                ClusterState =
                {
                    new FetchDeploymentStateResponse.Types.DeployedClusterState(),
                },
                Unavailable =
                {
                    "unavailable48e06070",
                },
            };

            mockGrpcClient.Setup(x => x.FetchDeploymentState(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            GameServerDeploymentsServiceClient client   = new GameServerDeploymentsServiceClientImpl(mockGrpcClient.Object, null);
            FetchDeploymentStateResponse       response = client.FetchDeploymentState(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task FetchDeploymentStateRequestObjectAsync()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            FetchDeploymentStateRequest request = new FetchDeploymentStateRequest
            {
                Name = "name1c9368b0",
            };
            FetchDeploymentStateResponse expectedResponse = new FetchDeploymentStateResponse
            {
                ClusterState =
                {
                    new FetchDeploymentStateResponse.Types.DeployedClusterState(),
                },
                Unavailable =
                {
                    "unavailable48e06070",
                },
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task PreviewGameServerDeploymentRolloutRequestObjectAsync()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            PreviewGameServerDeploymentRolloutRequest request = new PreviewGameServerDeploymentRolloutRequest
            {
                Rollout     = new GameServerDeploymentRollout(),
                UpdateMask  = new wkt::FieldMask(),
                PreviewTime = new wkt::Timestamp(),
            };
            PreviewGameServerDeploymentRolloutResponse expectedResponse = new PreviewGameServerDeploymentRolloutResponse
            {
                Unavailable =
                {
                    "unavailable48e06070",
                },
                Etag        = "etage8ad7218",
                TargetState = new TargetState(),
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void PreviewGameServerDeploymentRolloutRequestObject()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            PreviewGameServerDeploymentRolloutRequest request = new PreviewGameServerDeploymentRolloutRequest
            {
                Rollout     = new GameServerDeploymentRollout(),
                UpdateMask  = new wkt::FieldMask(),
                PreviewTime = new wkt::Timestamp(),
            };
            PreviewGameServerDeploymentRolloutResponse expectedResponse = new PreviewGameServerDeploymentRolloutResponse
            {
                Unavailable =
                {
                    "unavailable48e06070",
                },
                Etag        = "etage8ad7218",
                TargetState = new TargetState(),
            };

            mockGrpcClient.Setup(x => x.PreviewGameServerDeploymentRollout(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            GameServerDeploymentsServiceClient         client   = new GameServerDeploymentsServiceClientImpl(mockGrpcClient.Object, null);
            PreviewGameServerDeploymentRolloutResponse response = client.PreviewGameServerDeploymentRollout(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task GetGameServerDeploymentRolloutResourceNamesAsync()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetGameServerDeploymentRolloutRequest request = new GetGameServerDeploymentRolloutRequest
            {
                GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
            };
            GameServerDeploymentRollout expectedResponse = new GameServerDeploymentRollout
            {
                GameServerDeploymentRolloutName = GameServerDeploymentRolloutName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
                CreateTime = new wkt::Timestamp(),
                UpdateTime = new wkt::Timestamp(),
                DefaultGameServerConfig   = "default_game_server_config2214de2f",
                GameServerConfigOverrides =
                {
                    new GameServerConfigOverride(),
                },
                Etag = "etage8ad7218",
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            GameServerDeploymentRollout responseCancellationToken = await client.GetGameServerDeploymentRolloutAsync(request.GameServerDeploymentName, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void GetGameServerDeploymentRolloutResourceNames()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetGameServerDeploymentRolloutRequest request = new GetGameServerDeploymentRolloutRequest
            {
                GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
            };
            GameServerDeploymentRollout expectedResponse = new GameServerDeploymentRollout
            {
                GameServerDeploymentRolloutName = GameServerDeploymentRolloutName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
                CreateTime = new wkt::Timestamp(),
                UpdateTime = new wkt::Timestamp(),
                DefaultGameServerConfig   = "default_game_server_config2214de2f",
                GameServerConfigOverrides =
                {
                    new GameServerConfigOverride(),
                },
                Etag = "etage8ad7218",
            };

            mockGrpcClient.Setup(x => x.GetGameServerDeploymentRollout(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            GameServerDeploymentsServiceClient client   = new GameServerDeploymentsServiceClientImpl(mockGrpcClient.Object, null);
            GameServerDeploymentRollout        response = client.GetGameServerDeploymentRollout(request.GameServerDeploymentName);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void GetGameServerDeploymentRequestObject()
        {
            moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient> mockGrpcClient = new moq::Mock <GameServerDeploymentsService.GameServerDeploymentsServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetGameServerDeploymentRequest request = new GetGameServerDeploymentRequest
            {
                GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
            };
            GameServerDeployment expectedResponse = new GameServerDeployment
            {
                GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"),
                CreateTime = new wkt::Timestamp(),
                UpdateTime = new wkt::Timestamp(),
                Labels     =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                Etag        = "etage8ad7218",
                Description = "description2cf9da67",
            };

            mockGrpcClient.Setup(x => x.GetGameServerDeployment(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            GameServerDeploymentsServiceClient client = new GameServerDeploymentsServiceClientImpl(mockGrpcClient.Object, null);
            GameServerDeployment response             = client.GetGameServerDeployment(request);

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