ChatServiceClientHttpJsonTest.java

/*
 * Copyright 2026 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.chat.v1;

import static com.google.chat.v1.ChatServiceClient.FindGroupChatsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListCustomEmojisPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListMembershipsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListMessagePinsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListMessagesPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListReactionsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListSectionItemsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListSectionsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListSpaceEventsPagedResponse;
import static com.google.chat.v1.ChatServiceClient.ListSpacesPagedResponse;
import static com.google.chat.v1.ChatServiceClient.SearchMessagesPagedResponse;
import static com.google.chat.v1.ChatServiceClient.SearchSpacesPagedResponse;

import com.google.api.gax.core.NoCredentialsProvider;
import com.google.api.gax.httpjson.GaxHttpJsonProperties;
import com.google.api.gax.httpjson.testing.MockHttpService;
import com.google.api.gax.rpc.ApiClientHeaderProvider;
import com.google.api.gax.rpc.ApiException;
import com.google.api.gax.rpc.ApiExceptionFactory;
import com.google.api.gax.rpc.InvalidArgumentException;
import com.google.api.gax.rpc.StatusCode;
import com.google.api.gax.rpc.testing.FakeStatusCode;
import com.google.chat.v1.stub.HttpJsonChatServiceStub;
import com.google.common.collect.Lists;
import com.google.protobuf.Empty;
import com.google.protobuf.FieldMask;
import com.google.protobuf.Timestamp;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Generated;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

@Generated("by gapic-generator-java")
public class ChatServiceClientHttpJsonTest {
  private static MockHttpService mockService;
  private static ChatServiceClient client;

  @BeforeClass
  public static void startStaticServer() throws IOException {
    mockService =
        new MockHttpService(
            HttpJsonChatServiceStub.getMethodDescriptors(),
            ChatServiceSettings.getDefaultEndpoint());
    ChatServiceSettings settings =
        ChatServiceSettings.newHttpJsonBuilder()
            .setTransportChannelProvider(
                ChatServiceSettings.defaultHttpJsonTransportProviderBuilder()
                    .setHttpTransport(mockService)
                    .build())
            .setCredentialsProvider(NoCredentialsProvider.create())
            .build();
    client = ChatServiceClient.create(settings);
  }

  @AfterClass
  public static void stopServer() {
    client.close();
  }

  @Before
  public void setUp() {}

  @After
  public void tearDown() throws Exception {
    mockService.reset();
  }

  @Test
  public void createMessageTest() throws Exception {
    Message expectedResponse =
        Message.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .setSender(User.newBuilder().build())
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastUpdateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .setText("text3556653")
            .setFormattedText("formattedText-1717326839")
            .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .addAllAnnotations(new ArrayList<Annotation>())
            .setThread(Thread.newBuilder().build())
            .setSpace(Space.newBuilder().build())
            .setFallbackText("fallbackText-1783292113")
            .setActionResponse(ActionResponse.newBuilder().build())
            .setArgumentText("argumentText552563082")
            .setSlashCommand(SlashCommand.newBuilder().build())
            .addAllAttachment(new ArrayList<Attachment>())
            .setMatchedUrl(MatchedUrl.newBuilder().build())
            .setThreadReply(true)
            .setSilent(true)
            .setClientAssignedMessageId("clientAssignedMessageId-750462775")
            .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
            .setPrivateMessageViewer(User.newBuilder().build())
            .setDeletionMetadata(DeletionMetadata.newBuilder().build())
            .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
            .addAllAttachedGifs(new ArrayList<AttachedGif>())
            .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
            .setElements(Elements.newBuilder().build())
            .setMarkupSyntax(MarkupSyntax.forNumber(0))
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");
    Message message = Message.newBuilder().build();
    String messageId = "messageId-1440013438";

    Message actualResponse = client.createMessage(parent, message, messageId);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createMessageExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      Message message = Message.newBuilder().build();
      String messageId = "messageId-1440013438";
      client.createMessage(parent, message, messageId);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createMessageTest2() throws Exception {
    Message expectedResponse =
        Message.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .setSender(User.newBuilder().build())
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastUpdateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .setText("text3556653")
            .setFormattedText("formattedText-1717326839")
            .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .addAllAnnotations(new ArrayList<Annotation>())
            .setThread(Thread.newBuilder().build())
            .setSpace(Space.newBuilder().build())
            .setFallbackText("fallbackText-1783292113")
            .setActionResponse(ActionResponse.newBuilder().build())
            .setArgumentText("argumentText552563082")
            .setSlashCommand(SlashCommand.newBuilder().build())
            .addAllAttachment(new ArrayList<Attachment>())
            .setMatchedUrl(MatchedUrl.newBuilder().build())
            .setThreadReply(true)
            .setSilent(true)
            .setClientAssignedMessageId("clientAssignedMessageId-750462775")
            .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
            .setPrivateMessageViewer(User.newBuilder().build())
            .setDeletionMetadata(DeletionMetadata.newBuilder().build())
            .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
            .addAllAttachedGifs(new ArrayList<AttachedGif>())
            .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
            .setElements(Elements.newBuilder().build())
            .setMarkupSyntax(MarkupSyntax.forNumber(0))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";
    Message message = Message.newBuilder().build();
    String messageId = "messageId-1440013438";

    Message actualResponse = client.createMessage(parent, message, messageId);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createMessageExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      Message message = Message.newBuilder().build();
      String messageId = "messageId-1440013438";
      client.createMessage(parent, message, messageId);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listMessagesTest() throws Exception {
    Message responsesElement = Message.newBuilder().build();
    ListMessagesResponse expectedResponse =
        ListMessagesResponse.newBuilder()
            .setNextPageToken("")
            .addAllMessages(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");

    ListMessagesPagedResponse pagedListResponse = client.listMessages(parent);

    List<Message> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getMessagesList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listMessagesExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      client.listMessages(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listMessagesTest2() throws Exception {
    Message responsesElement = Message.newBuilder().build();
    ListMessagesResponse expectedResponse =
        ListMessagesResponse.newBuilder()
            .setNextPageToken("")
            .addAllMessages(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";

    ListMessagesPagedResponse pagedListResponse = client.listMessages(parent);

    List<Message> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getMessagesList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listMessagesExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      client.listMessages(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listMembershipsTest() throws Exception {
    Membership responsesElement = Membership.newBuilder().build();
    ListMembershipsResponse expectedResponse =
        ListMembershipsResponse.newBuilder()
            .setNextPageToken("")
            .addAllMemberships(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");

    ListMembershipsPagedResponse pagedListResponse = client.listMemberships(parent);

    List<Membership> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getMembershipsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listMembershipsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      client.listMemberships(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listMembershipsTest2() throws Exception {
    Membership responsesElement = Membership.newBuilder().build();
    ListMembershipsResponse expectedResponse =
        ListMembershipsResponse.newBuilder()
            .setNextPageToken("")
            .addAllMemberships(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";

    ListMembershipsPagedResponse pagedListResponse = client.listMemberships(parent);

    List<Membership> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getMembershipsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listMembershipsExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      client.listMemberships(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getMembershipTest() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    MembershipName name = MembershipName.of("[SPACE]", "[MEMBER]");

    Membership actualResponse = client.getMembership(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getMembershipExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MembershipName name = MembershipName.of("[SPACE]", "[MEMBER]");
      client.getMembership(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getMembershipTest2() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-6456/members/member-6456";

    Membership actualResponse = client.getMembership(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getMembershipExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-6456/members/member-6456";
      client.getMembership(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getMessageTest() throws Exception {
    Message expectedResponse =
        Message.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .setSender(User.newBuilder().build())
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastUpdateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .setText("text3556653")
            .setFormattedText("formattedText-1717326839")
            .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .addAllAnnotations(new ArrayList<Annotation>())
            .setThread(Thread.newBuilder().build())
            .setSpace(Space.newBuilder().build())
            .setFallbackText("fallbackText-1783292113")
            .setActionResponse(ActionResponse.newBuilder().build())
            .setArgumentText("argumentText552563082")
            .setSlashCommand(SlashCommand.newBuilder().build())
            .addAllAttachment(new ArrayList<Attachment>())
            .setMatchedUrl(MatchedUrl.newBuilder().build())
            .setThreadReply(true)
            .setSilent(true)
            .setClientAssignedMessageId("clientAssignedMessageId-750462775")
            .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
            .setPrivateMessageViewer(User.newBuilder().build())
            .setDeletionMetadata(DeletionMetadata.newBuilder().build())
            .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
            .addAllAttachedGifs(new ArrayList<AttachedGif>())
            .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
            .setElements(Elements.newBuilder().build())
            .setMarkupSyntax(MarkupSyntax.forNumber(0))
            .build();
    mockService.addResponse(expectedResponse);

    MessageName name = MessageName.of("[SPACE]", "[MESSAGE]");

    Message actualResponse = client.getMessage(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getMessageExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MessageName name = MessageName.of("[SPACE]", "[MESSAGE]");
      client.getMessage(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getMessageTest2() throws Exception {
    Message expectedResponse =
        Message.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .setSender(User.newBuilder().build())
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastUpdateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .setText("text3556653")
            .setFormattedText("formattedText-1717326839")
            .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .addAllAnnotations(new ArrayList<Annotation>())
            .setThread(Thread.newBuilder().build())
            .setSpace(Space.newBuilder().build())
            .setFallbackText("fallbackText-1783292113")
            .setActionResponse(ActionResponse.newBuilder().build())
            .setArgumentText("argumentText552563082")
            .setSlashCommand(SlashCommand.newBuilder().build())
            .addAllAttachment(new ArrayList<Attachment>())
            .setMatchedUrl(MatchedUrl.newBuilder().build())
            .setThreadReply(true)
            .setSilent(true)
            .setClientAssignedMessageId("clientAssignedMessageId-750462775")
            .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
            .setPrivateMessageViewer(User.newBuilder().build())
            .setDeletionMetadata(DeletionMetadata.newBuilder().build())
            .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
            .addAllAttachedGifs(new ArrayList<AttachedGif>())
            .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
            .setElements(Elements.newBuilder().build())
            .setMarkupSyntax(MarkupSyntax.forNumber(0))
            .build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-765/messages/message-765";

    Message actualResponse = client.getMessage(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getMessageExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-765/messages/message-765";
      client.getMessage(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateMessageTest() throws Exception {
    Message expectedResponse =
        Message.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .setSender(User.newBuilder().build())
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastUpdateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .setText("text3556653")
            .setFormattedText("formattedText-1717326839")
            .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .addAllAnnotations(new ArrayList<Annotation>())
            .setThread(Thread.newBuilder().build())
            .setSpace(Space.newBuilder().build())
            .setFallbackText("fallbackText-1783292113")
            .setActionResponse(ActionResponse.newBuilder().build())
            .setArgumentText("argumentText552563082")
            .setSlashCommand(SlashCommand.newBuilder().build())
            .addAllAttachment(new ArrayList<Attachment>())
            .setMatchedUrl(MatchedUrl.newBuilder().build())
            .setThreadReply(true)
            .setSilent(true)
            .setClientAssignedMessageId("clientAssignedMessageId-750462775")
            .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
            .setPrivateMessageViewer(User.newBuilder().build())
            .setDeletionMetadata(DeletionMetadata.newBuilder().build())
            .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
            .addAllAttachedGifs(new ArrayList<AttachedGif>())
            .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
            .setElements(Elements.newBuilder().build())
            .setMarkupSyntax(MarkupSyntax.forNumber(0))
            .build();
    mockService.addResponse(expectedResponse);

    Message message =
        Message.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .setSender(User.newBuilder().build())
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastUpdateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .setText("text3556653")
            .setFormattedText("formattedText-1717326839")
            .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .addAllAnnotations(new ArrayList<Annotation>())
            .setThread(Thread.newBuilder().build())
            .setSpace(Space.newBuilder().build())
            .setFallbackText("fallbackText-1783292113")
            .setActionResponse(ActionResponse.newBuilder().build())
            .setArgumentText("argumentText552563082")
            .setSlashCommand(SlashCommand.newBuilder().build())
            .addAllAttachment(new ArrayList<Attachment>())
            .setMatchedUrl(MatchedUrl.newBuilder().build())
            .setThreadReply(true)
            .setSilent(true)
            .setClientAssignedMessageId("clientAssignedMessageId-750462775")
            .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
            .setPrivateMessageViewer(User.newBuilder().build())
            .setDeletionMetadata(DeletionMetadata.newBuilder().build())
            .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
            .addAllAttachedGifs(new ArrayList<AttachedGif>())
            .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
            .setElements(Elements.newBuilder().build())
            .setMarkupSyntax(MarkupSyntax.forNumber(0))
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    Message actualResponse = client.updateMessage(message, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateMessageExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      Message message =
          Message.newBuilder()
              .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
              .setSender(User.newBuilder().build())
              .setCreateTime(Timestamp.newBuilder().build())
              .setLastUpdateTime(Timestamp.newBuilder().build())
              .setDeleteTime(Timestamp.newBuilder().build())
              .setText("text3556653")
              .setFormattedText("formattedText-1717326839")
              .addAllCards(new ArrayList<ContextualAddOnMarkup.Card>())
              .addAllCardsV2(new ArrayList<CardWithId>())
              .addAllAnnotations(new ArrayList<Annotation>())
              .setThread(Thread.newBuilder().build())
              .setSpace(Space.newBuilder().build())
              .setFallbackText("fallbackText-1783292113")
              .setActionResponse(ActionResponse.newBuilder().build())
              .setArgumentText("argumentText552563082")
              .setSlashCommand(SlashCommand.newBuilder().build())
              .addAllAttachment(new ArrayList<Attachment>())
              .setMatchedUrl(MatchedUrl.newBuilder().build())
              .setThreadReply(true)
              .setSilent(true)
              .setClientAssignedMessageId("clientAssignedMessageId-750462775")
              .addAllEmojiReactionSummaries(new ArrayList<EmojiReactionSummary>())
              .setPrivateMessageViewer(User.newBuilder().build())
              .setDeletionMetadata(DeletionMetadata.newBuilder().build())
              .setQuotedMessageMetadata(QuotedMessageMetadata.newBuilder().build())
              .addAllAttachedGifs(new ArrayList<AttachedGif>())
              .addAllAccessoryWidgets(new ArrayList<AccessoryWidget>())
              .setElements(Elements.newBuilder().build())
              .setMarkupSyntax(MarkupSyntax.forNumber(0))
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateMessage(message, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteMessageTest() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    MessageName name = MessageName.of("[SPACE]", "[MESSAGE]");

    client.deleteMessage(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteMessageExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MessageName name = MessageName.of("[SPACE]", "[MESSAGE]");
      client.deleteMessage(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteMessageTest2() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-765/messages/message-765";

    client.deleteMessage(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteMessageExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-765/messages/message-765";
      client.deleteMessage(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void searchMessagesTest() throws Exception {
    SearchMessageResult responsesElement = SearchMessageResult.newBuilder().build();
    SearchMessagesResponse expectedResponse =
        SearchMessagesResponse.newBuilder()
            .setNextPageToken("")
            .addAllResults(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");
    String filter = "filter-1274492040";

    SearchMessagesPagedResponse pagedListResponse = client.searchMessages(parent, filter);

    List<SearchMessageResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getResultsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void searchMessagesExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      String filter = "filter-1274492040";
      client.searchMessages(parent, filter);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void searchMessagesTest2() throws Exception {
    SearchMessageResult responsesElement = SearchMessageResult.newBuilder().build();
    SearchMessagesResponse expectedResponse =
        SearchMessagesResponse.newBuilder()
            .setNextPageToken("")
            .addAllResults(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";
    String filter = "filter-1274492040";

    SearchMessagesPagedResponse pagedListResponse = client.searchMessages(parent, filter);

    List<SearchMessageResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getResultsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void searchMessagesExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      String filter = "filter-1274492040";
      client.searchMessages(parent, filter);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getAttachmentTest() throws Exception {
    Attachment expectedResponse =
        Attachment.newBuilder()
            .setName(AttachmentName.of("[SPACE]", "[MESSAGE]", "[ATTACHMENT]").toString())
            .setContentName("contentName-389333340")
            .setContentType("contentType-389131437")
            .setThumbnailUri("thumbnailUri-356760352")
            .setDownloadUri("downloadUri-1211148348")
            .build();
    mockService.addResponse(expectedResponse);

    AttachmentName name = AttachmentName.of("[SPACE]", "[MESSAGE]", "[ATTACHMENT]");

    Attachment actualResponse = client.getAttachment(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getAttachmentExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      AttachmentName name = AttachmentName.of("[SPACE]", "[MESSAGE]", "[ATTACHMENT]");
      client.getAttachment(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getAttachmentTest2() throws Exception {
    Attachment expectedResponse =
        Attachment.newBuilder()
            .setName(AttachmentName.of("[SPACE]", "[MESSAGE]", "[ATTACHMENT]").toString())
            .setContentName("contentName-389333340")
            .setContentType("contentType-389131437")
            .setThumbnailUri("thumbnailUri-356760352")
            .setDownloadUri("downloadUri-1211148348")
            .build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-8657/messages/message-8657/attachments/attachment-8657";

    Attachment actualResponse = client.getAttachment(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getAttachmentExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-8657/messages/message-8657/attachments/attachment-8657";
      client.getAttachment(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void uploadAttachmentTest() throws Exception {
    UploadAttachmentResponse expectedResponse =
        UploadAttachmentResponse.newBuilder()
            .setAttachmentDataRef(AttachmentDataRef.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    UploadAttachmentRequest request =
        UploadAttachmentRequest.newBuilder()
            .setParent(SpaceName.of("[SPACE]").toString())
            .setFilename("filename-734768633")
            .build();

    UploadAttachmentResponse actualResponse = client.uploadAttachment(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void uploadAttachmentExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      UploadAttachmentRequest request =
          UploadAttachmentRequest.newBuilder()
              .setParent(SpaceName.of("[SPACE]").toString())
              .setFilename("filename-734768633")
              .build();
      client.uploadAttachment(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSpacesTest() throws Exception {
    Space responsesElement = Space.newBuilder().build();
    ListSpacesResponse expectedResponse =
        ListSpacesResponse.newBuilder()
            .setNextPageToken("")
            .addAllSpaces(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    ListSpacesPagedResponse pagedListResponse = client.listSpaces();

    List<Space> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSpacesList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSpacesExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      ListSpacesRequest request =
          ListSpacesRequest.newBuilder()
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      client.listSpaces(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void searchSpacesTest() throws Exception {
    Space responsesElement = Space.newBuilder().build();
    SearchSpacesResponse expectedResponse =
        SearchSpacesResponse.newBuilder()
            .setNextPageToken("")
            .addAllSpaces(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SearchSpacesPagedResponse pagedListResponse = client.searchSpaces();

    List<Space> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSpacesList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void searchSpacesExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SearchSpacesRequest request =
          SearchSpacesRequest.newBuilder()
              .setUseAdminAccess(true)
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setQuery("query107944136")
              .setOrderBy("orderBy-1207110587")
              .build();
      client.searchSpaces(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceTest() throws Exception {
    Space expectedResponse =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName name = SpaceName.of("[SPACE]");

    Space actualResponse = client.getSpace(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName name = SpaceName.of("[SPACE]");
      client.getSpace(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceTest2() throws Exception {
    Space expectedResponse =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-5469";

    Space actualResponse = client.getSpace(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-5469";
      client.getSpace(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createSpaceTest() throws Exception {
    Space expectedResponse =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    Space space = Space.newBuilder().build();

    Space actualResponse = client.createSpace(space);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createSpaceExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      Space space = Space.newBuilder().build();
      client.createSpace(space);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void setUpSpaceTest() throws Exception {
    Space expectedResponse =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SetUpSpaceRequest request =
        SetUpSpaceRequest.newBuilder()
            .setSpace(Space.newBuilder().build())
            .setRequestId("requestId693933066")
            .addAllMemberships(new ArrayList<Membership>())
            .build();

    Space actualResponse = client.setUpSpace(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void setUpSpaceExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SetUpSpaceRequest request =
          SetUpSpaceRequest.newBuilder()
              .setSpace(Space.newBuilder().build())
              .setRequestId("requestId693933066")
              .addAllMemberships(new ArrayList<Membership>())
              .build();
      client.setUpSpace(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateSpaceTest() throws Exception {
    Space expectedResponse =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    Space space =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    Space actualResponse = client.updateSpace(space, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateSpaceExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      Space space =
          Space.newBuilder()
              .setName(SpaceName.of("[SPACE]").toString())
              .setSingleUserBotDm(true)
              .setThreaded(true)
              .setDisplayName("displayName1714148973")
              .setExternalUserAllowed(true)
              .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
              .setSpaceHistoryState(HistoryState.forNumber(0))
              .setImportMode(true)
              .setCreateTime(Timestamp.newBuilder().build())
              .setLastActiveTime(Timestamp.newBuilder().build())
              .setAdminInstalled(true)
              .setMembershipCount(Space.MembershipCount.newBuilder().build())
              .setAccessSettings(Space.AccessSettings.newBuilder().build())
              .setCustomer("customer606175198")
              .setSpaceUri("spaceUri2047440518")
              .setImportModeExpireTime(Timestamp.newBuilder().build())
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateSpace(space, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteSpaceTest() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    SpaceName name = SpaceName.of("[SPACE]");

    client.deleteSpace(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteSpaceExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName name = SpaceName.of("[SPACE]");
      client.deleteSpace(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteSpaceTest2() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-5469";

    client.deleteSpace(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteSpaceExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-5469";
      client.deleteSpace(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void completeImportSpaceTest() throws Exception {
    CompleteImportSpaceResponse expectedResponse =
        CompleteImportSpaceResponse.newBuilder().setSpace(Space.newBuilder().build()).build();
    mockService.addResponse(expectedResponse);

    CompleteImportSpaceRequest request =
        CompleteImportSpaceRequest.newBuilder().setName(SpaceName.of("[SPACE]").toString()).build();

    CompleteImportSpaceResponse actualResponse = client.completeImportSpace(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void completeImportSpaceExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      CompleteImportSpaceRequest request =
          CompleteImportSpaceRequest.newBuilder()
              .setName(SpaceName.of("[SPACE]").toString())
              .build();
      client.completeImportSpace(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void findDirectMessageTest() throws Exception {
    Space expectedResponse =
        Space.newBuilder()
            .setName(SpaceName.of("[SPACE]").toString())
            .setSingleUserBotDm(true)
            .setThreaded(true)
            .setDisplayName("displayName1714148973")
            .setExternalUserAllowed(true)
            .setSpaceDetails(Space.SpaceDetails.newBuilder().build())
            .setSpaceHistoryState(HistoryState.forNumber(0))
            .setImportMode(true)
            .setCreateTime(Timestamp.newBuilder().build())
            .setLastActiveTime(Timestamp.newBuilder().build())
            .setAdminInstalled(true)
            .setMembershipCount(Space.MembershipCount.newBuilder().build())
            .setAccessSettings(Space.AccessSettings.newBuilder().build())
            .setCustomer("customer606175198")
            .setSpaceUri("spaceUri2047440518")
            .setImportModeExpireTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    FindDirectMessageRequest request =
        FindDirectMessageRequest.newBuilder().setName("name3373707").build();

    Space actualResponse = client.findDirectMessage(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void findDirectMessageExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      FindDirectMessageRequest request =
          FindDirectMessageRequest.newBuilder().setName("name3373707").build();
      client.findDirectMessage(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void findGroupChatsTest() throws Exception {
    Space responsesElement = Space.newBuilder().build();
    FindGroupChatsResponse expectedResponse =
        FindGroupChatsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSpaces(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    FindGroupChatsRequest request =
        FindGroupChatsRequest.newBuilder()
            .addAllUsers(new ArrayList<String>())
            .setPageSize(883849137)
            .setPageToken("pageToken873572522")
            .setSpaceView(SpaceView.forNumber(0))
            .build();

    FindGroupChatsPagedResponse pagedListResponse = client.findGroupChats(request);

    List<Space> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSpacesList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void findGroupChatsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      FindGroupChatsRequest request =
          FindGroupChatsRequest.newBuilder()
              .addAllUsers(new ArrayList<String>())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setSpaceView(SpaceView.forNumber(0))
              .build();
      client.findGroupChats(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createMembershipTest() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");
    Membership membership = Membership.newBuilder().build();

    Membership actualResponse = client.createMembership(parent, membership);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createMembershipExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      Membership membership = Membership.newBuilder().build();
      client.createMembership(parent, membership);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createMembershipTest2() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";
    Membership membership = Membership.newBuilder().build();

    Membership actualResponse = client.createMembership(parent, membership);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createMembershipExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      Membership membership = Membership.newBuilder().build();
      client.createMembership(parent, membership);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateMembershipTest() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    Membership membership =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    Membership actualResponse = client.updateMembership(membership, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateMembershipExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      Membership membership =
          Membership.newBuilder()
              .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
              .setCreateTime(Timestamp.newBuilder().build())
              .setDeleteTime(Timestamp.newBuilder().build())
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateMembership(membership, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteMembershipTest() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    MembershipName name = MembershipName.of("[SPACE]", "[MEMBER]");

    Membership actualResponse = client.deleteMembership(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteMembershipExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MembershipName name = MembershipName.of("[SPACE]", "[MEMBER]");
      client.deleteMembership(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteMembershipTest2() throws Exception {
    Membership expectedResponse =
        Membership.newBuilder()
            .setName(MembershipName.of("[SPACE]", "[MEMBER]").toString())
            .setCreateTime(Timestamp.newBuilder().build())
            .setDeleteTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-6456/members/member-6456";

    Membership actualResponse = client.deleteMembership(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteMembershipExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-6456/members/member-6456";
      client.deleteMembership(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createReactionTest() throws Exception {
    Reaction expectedResponse =
        Reaction.newBuilder()
            .setName(ReactionName.of("[SPACE]", "[MESSAGE]", "[REACTION]").toString())
            .setUser(User.newBuilder().build())
            .setEmoji(Emoji.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    MessageName parent = MessageName.of("[SPACE]", "[MESSAGE]");
    Reaction reaction = Reaction.newBuilder().build();

    Reaction actualResponse = client.createReaction(parent, reaction);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createReactionExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MessageName parent = MessageName.of("[SPACE]", "[MESSAGE]");
      Reaction reaction = Reaction.newBuilder().build();
      client.createReaction(parent, reaction);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createReactionTest2() throws Exception {
    Reaction expectedResponse =
        Reaction.newBuilder()
            .setName(ReactionName.of("[SPACE]", "[MESSAGE]", "[REACTION]").toString())
            .setUser(User.newBuilder().build())
            .setEmoji(Emoji.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-8748/messages/message-8748";
    Reaction reaction = Reaction.newBuilder().build();

    Reaction actualResponse = client.createReaction(parent, reaction);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createReactionExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-8748/messages/message-8748";
      Reaction reaction = Reaction.newBuilder().build();
      client.createReaction(parent, reaction);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listReactionsTest() throws Exception {
    Reaction responsesElement = Reaction.newBuilder().build();
    ListReactionsResponse expectedResponse =
        ListReactionsResponse.newBuilder()
            .setNextPageToken("")
            .addAllReactions(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    MessageName parent = MessageName.of("[SPACE]", "[MESSAGE]");

    ListReactionsPagedResponse pagedListResponse = client.listReactions(parent);

    List<Reaction> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getReactionsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listReactionsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MessageName parent = MessageName.of("[SPACE]", "[MESSAGE]");
      client.listReactions(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listReactionsTest2() throws Exception {
    Reaction responsesElement = Reaction.newBuilder().build();
    ListReactionsResponse expectedResponse =
        ListReactionsResponse.newBuilder()
            .setNextPageToken("")
            .addAllReactions(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-8748/messages/message-8748";

    ListReactionsPagedResponse pagedListResponse = client.listReactions(parent);

    List<Reaction> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getReactionsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listReactionsExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-8748/messages/message-8748";
      client.listReactions(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteReactionTest() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    ReactionName name = ReactionName.of("[SPACE]", "[MESSAGE]", "[REACTION]");

    client.deleteReaction(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteReactionExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      ReactionName name = ReactionName.of("[SPACE]", "[MESSAGE]", "[REACTION]");
      client.deleteReaction(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteReactionTest2() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-9479/messages/message-9479/reactions/reaction-9479";

    client.deleteReaction(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteReactionExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-9479/messages/message-9479/reactions/reaction-9479";
      client.deleteReaction(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listMessagePinsTest() throws Exception {
    MessagePin responsesElement = MessagePin.newBuilder().build();
    ListMessagePinsResponse expectedResponse =
        ListMessagePinsResponse.newBuilder()
            .setNextPageToken("")
            .addAllMessagePins(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");

    ListMessagePinsPagedResponse pagedListResponse = client.listMessagePins(parent);

    List<MessagePin> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getMessagePinsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listMessagePinsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      client.listMessagePins(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listMessagePinsTest2() throws Exception {
    MessagePin responsesElement = MessagePin.newBuilder().build();
    ListMessagePinsResponse expectedResponse =
        ListMessagePinsResponse.newBuilder()
            .setNextPageToken("")
            .addAllMessagePins(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";

    ListMessagePinsPagedResponse pagedListResponse = client.listMessagePins(parent);

    List<MessagePin> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getMessagePinsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listMessagePinsExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      client.listMessagePins(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createMessagePinTest() throws Exception {
    MessagePin expectedResponse =
        MessagePin.newBuilder()
            .setName(MessagePinName.of("[SPACE]", "[MESSAGE_PIN]").toString())
            .setMessage(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");
    MessagePin messagePin = MessagePin.newBuilder().build();

    MessagePin actualResponse = client.createMessagePin(parent, messagePin);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createMessagePinExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      MessagePin messagePin = MessagePin.newBuilder().build();
      client.createMessagePin(parent, messagePin);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createMessagePinTest2() throws Exception {
    MessagePin expectedResponse =
        MessagePin.newBuilder()
            .setName(MessagePinName.of("[SPACE]", "[MESSAGE_PIN]").toString())
            .setMessage(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";
    MessagePin messagePin = MessagePin.newBuilder().build();

    MessagePin actualResponse = client.createMessagePin(parent, messagePin);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createMessagePinExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      MessagePin messagePin = MessagePin.newBuilder().build();
      client.createMessagePin(parent, messagePin);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteMessagePinTest() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    MessagePinName name = MessagePinName.of("[SPACE]", "[MESSAGE_PIN]");

    client.deleteMessagePin(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteMessagePinExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MessagePinName name = MessagePinName.of("[SPACE]", "[MESSAGE_PIN]");
      client.deleteMessagePin(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteMessagePinTest2() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-4524/messagePins/messagePin-4524";

    client.deleteMessagePin(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteMessagePinExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-4524/messagePins/messagePin-4524";
      client.deleteMessagePin(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createCustomEmojiTest() throws Exception {
    CustomEmoji expectedResponse =
        CustomEmoji.newBuilder()
            .setName(CustomEmojiName.of("[CUSTOM_EMOJI]").toString())
            .setUid("uid115792")
            .setEmojiName("emojiName1686232049")
            .setTemporaryImageUri("temporaryImageUri-1892195454")
            .setPayload(CustomEmoji.CustomEmojiPayload.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    CustomEmoji customEmoji = CustomEmoji.newBuilder().build();

    CustomEmoji actualResponse = client.createCustomEmoji(customEmoji);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createCustomEmojiExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      CustomEmoji customEmoji = CustomEmoji.newBuilder().build();
      client.createCustomEmoji(customEmoji);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getCustomEmojiTest() throws Exception {
    CustomEmoji expectedResponse =
        CustomEmoji.newBuilder()
            .setName(CustomEmojiName.of("[CUSTOM_EMOJI]").toString())
            .setUid("uid115792")
            .setEmojiName("emojiName1686232049")
            .setTemporaryImageUri("temporaryImageUri-1892195454")
            .setPayload(CustomEmoji.CustomEmojiPayload.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    CustomEmojiName name = CustomEmojiName.of("[CUSTOM_EMOJI]");

    CustomEmoji actualResponse = client.getCustomEmoji(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getCustomEmojiExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      CustomEmojiName name = CustomEmojiName.of("[CUSTOM_EMOJI]");
      client.getCustomEmoji(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getCustomEmojiTest2() throws Exception {
    CustomEmoji expectedResponse =
        CustomEmoji.newBuilder()
            .setName(CustomEmojiName.of("[CUSTOM_EMOJI]").toString())
            .setUid("uid115792")
            .setEmojiName("emojiName1686232049")
            .setTemporaryImageUri("temporaryImageUri-1892195454")
            .setPayload(CustomEmoji.CustomEmojiPayload.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "customEmojis/customEmoji-6372";

    CustomEmoji actualResponse = client.getCustomEmoji(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getCustomEmojiExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "customEmojis/customEmoji-6372";
      client.getCustomEmoji(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listCustomEmojisTest() throws Exception {
    CustomEmoji responsesElement = CustomEmoji.newBuilder().build();
    ListCustomEmojisResponse expectedResponse =
        ListCustomEmojisResponse.newBuilder()
            .setNextPageToken("")
            .addAllCustomEmojis(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    ListCustomEmojisPagedResponse pagedListResponse = client.listCustomEmojis();

    List<CustomEmoji> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getCustomEmojisList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listCustomEmojisExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      ListCustomEmojisRequest request =
          ListCustomEmojisRequest.newBuilder()
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      client.listCustomEmojis(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteCustomEmojiTest() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    CustomEmojiName name = CustomEmojiName.of("[CUSTOM_EMOJI]");

    client.deleteCustomEmoji(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteCustomEmojiExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      CustomEmojiName name = CustomEmojiName.of("[CUSTOM_EMOJI]");
      client.deleteCustomEmoji(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteCustomEmojiTest2() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    String name = "customEmojis/customEmoji-6372";

    client.deleteCustomEmoji(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteCustomEmojiExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "customEmojis/customEmoji-6372";
      client.deleteCustomEmoji(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceReadStateTest() throws Exception {
    SpaceReadState expectedResponse =
        SpaceReadState.newBuilder()
            .setName(SpaceReadStateName.of("[USER]", "[SPACE]").toString())
            .setLastReadTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceReadStateName name = SpaceReadStateName.of("[USER]", "[SPACE]");

    SpaceReadState actualResponse = client.getSpaceReadState(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceReadStateExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceReadStateName name = SpaceReadStateName.of("[USER]", "[SPACE]");
      client.getSpaceReadState(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceReadStateTest2() throws Exception {
    SpaceReadState expectedResponse =
        SpaceReadState.newBuilder()
            .setName(SpaceReadStateName.of("[USER]", "[SPACE]").toString())
            .setLastReadTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-2197/spaces/space-2197/spaceReadState";

    SpaceReadState actualResponse = client.getSpaceReadState(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceReadStateExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-2197/spaces/space-2197/spaceReadState";
      client.getSpaceReadState(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateSpaceReadStateTest() throws Exception {
    SpaceReadState expectedResponse =
        SpaceReadState.newBuilder()
            .setName(SpaceReadStateName.of("[USER]", "[SPACE]").toString())
            .setLastReadTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceReadState spaceReadState =
        SpaceReadState.newBuilder()
            .setName(SpaceReadStateName.of("[USER]", "[SPACE]").toString())
            .setLastReadTime(Timestamp.newBuilder().build())
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    SpaceReadState actualResponse = client.updateSpaceReadState(spaceReadState, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateSpaceReadStateExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceReadState spaceReadState =
          SpaceReadState.newBuilder()
              .setName(SpaceReadStateName.of("[USER]", "[SPACE]").toString())
              .setLastReadTime(Timestamp.newBuilder().build())
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateSpaceReadState(spaceReadState, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getThreadReadStateTest() throws Exception {
    ThreadReadState expectedResponse =
        ThreadReadState.newBuilder()
            .setName(ThreadReadStateName.of("[USER]", "[SPACE]", "[THREAD]").toString())
            .setLastReadTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    ThreadReadStateName name = ThreadReadStateName.of("[USER]", "[SPACE]", "[THREAD]");

    ThreadReadState actualResponse = client.getThreadReadState(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getThreadReadStateExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      ThreadReadStateName name = ThreadReadStateName.of("[USER]", "[SPACE]", "[THREAD]");
      client.getThreadReadState(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getThreadReadStateTest2() throws Exception {
    ThreadReadState expectedResponse =
        ThreadReadState.newBuilder()
            .setName(ThreadReadStateName.of("[USER]", "[SPACE]", "[THREAD]").toString())
            .setLastReadTime(Timestamp.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-8554/spaces/space-8554/threads/thread-8554/threadReadState";

    ThreadReadState actualResponse = client.getThreadReadState(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getThreadReadStateExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-8554/spaces/space-8554/threads/thread-8554/threadReadState";
      client.getThreadReadState(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getAvailabilityTest() throws Exception {
    Availability expectedResponse =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    AvailabilityName name = AvailabilityName.of("[USER]");

    Availability actualResponse = client.getAvailability(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getAvailabilityExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      AvailabilityName name = AvailabilityName.of("[USER]");
      client.getAvailability(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getAvailabilityTest2() throws Exception {
    Availability expectedResponse =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-3694/availability";

    Availability actualResponse = client.getAvailability(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getAvailabilityExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-3694/availability";
      client.getAvailability(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void markAsActiveTest() throws Exception {
    Availability expectedResponse =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    MarkAsActiveRequest request =
        MarkAsActiveRequest.newBuilder().setName(AvailabilityName.of("[USER]").toString()).build();

    Availability actualResponse = client.markAsActive(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void markAsActiveExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MarkAsActiveRequest request =
          MarkAsActiveRequest.newBuilder()
              .setName(AvailabilityName.of("[USER]").toString())
              .build();
      client.markAsActive(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void markAsAwayTest() throws Exception {
    Availability expectedResponse =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    MarkAsAwayRequest request =
        MarkAsAwayRequest.newBuilder().setName(AvailabilityName.of("[USER]").toString()).build();

    Availability actualResponse = client.markAsAway(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void markAsAwayExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MarkAsAwayRequest request =
          MarkAsAwayRequest.newBuilder().setName(AvailabilityName.of("[USER]").toString()).build();
      client.markAsAway(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void markAsDoNotDisturbTest() throws Exception {
    Availability expectedResponse =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    MarkAsDoNotDisturbRequest request =
        MarkAsDoNotDisturbRequest.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .build();

    Availability actualResponse = client.markAsDoNotDisturb(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void markAsDoNotDisturbExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      MarkAsDoNotDisturbRequest request =
          MarkAsDoNotDisturbRequest.newBuilder()
              .setName(AvailabilityName.of("[USER]").toString())
              .build();
      client.markAsDoNotDisturb(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateAvailabilityTest() throws Exception {
    Availability expectedResponse =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    Availability availability =
        Availability.newBuilder()
            .setName(AvailabilityName.of("[USER]").toString())
            .setCustomStatus(CustomStatus.newBuilder().build())
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    Availability actualResponse = client.updateAvailability(availability, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateAvailabilityExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      Availability availability =
          Availability.newBuilder()
              .setName(AvailabilityName.of("[USER]").toString())
              .setCustomStatus(CustomStatus.newBuilder().build())
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateAvailability(availability, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceEventTest() throws Exception {
    SpaceEvent expectedResponse =
        SpaceEvent.newBuilder()
            .setName(SpaceEventName.of("[SPACE]", "[SPACE_EVENT]").toString())
            .setEventTime(Timestamp.newBuilder().build())
            .setEventType("eventType31430900")
            .build();
    mockService.addResponse(expectedResponse);

    SpaceEventName name = SpaceEventName.of("[SPACE]", "[SPACE_EVENT]");

    SpaceEvent actualResponse = client.getSpaceEvent(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceEventExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceEventName name = SpaceEventName.of("[SPACE]", "[SPACE_EVENT]");
      client.getSpaceEvent(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceEventTest2() throws Exception {
    SpaceEvent expectedResponse =
        SpaceEvent.newBuilder()
            .setName(SpaceEventName.of("[SPACE]", "[SPACE_EVENT]").toString())
            .setEventTime(Timestamp.newBuilder().build())
            .setEventType("eventType31430900")
            .build();
    mockService.addResponse(expectedResponse);

    String name = "spaces/space-8926/spaceEvents/spaceEvent-8926";

    SpaceEvent actualResponse = client.getSpaceEvent(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceEventExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "spaces/space-8926/spaceEvents/spaceEvent-8926";
      client.getSpaceEvent(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSpaceEventsTest() throws Exception {
    SpaceEvent responsesElement = SpaceEvent.newBuilder().build();
    ListSpaceEventsResponse expectedResponse =
        ListSpaceEventsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSpaceEvents(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SpaceName parent = SpaceName.of("[SPACE]");
    String filter = "filter-1274492040";

    ListSpaceEventsPagedResponse pagedListResponse = client.listSpaceEvents(parent, filter);

    List<SpaceEvent> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSpaceEventsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSpaceEventsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceName parent = SpaceName.of("[SPACE]");
      String filter = "filter-1274492040";
      client.listSpaceEvents(parent, filter);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSpaceEventsTest2() throws Exception {
    SpaceEvent responsesElement = SpaceEvent.newBuilder().build();
    ListSpaceEventsResponse expectedResponse =
        ListSpaceEventsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSpaceEvents(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "spaces/space-3870";
    String filter = "filter-1274492040";

    ListSpaceEventsPagedResponse pagedListResponse = client.listSpaceEvents(parent, filter);

    List<SpaceEvent> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSpaceEventsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSpaceEventsExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "spaces/space-3870";
      String filter = "filter-1274492040";
      client.listSpaceEvents(parent, filter);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceNotificationSettingTest() throws Exception {
    SpaceNotificationSetting expectedResponse =
        SpaceNotificationSetting.newBuilder()
            .setName(SpaceNotificationSettingName.of("[USER]", "[SPACE]").toString())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceNotificationSettingName name = SpaceNotificationSettingName.of("[USER]", "[SPACE]");

    SpaceNotificationSetting actualResponse = client.getSpaceNotificationSetting(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceNotificationSettingExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceNotificationSettingName name = SpaceNotificationSettingName.of("[USER]", "[SPACE]");
      client.getSpaceNotificationSetting(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void getSpaceNotificationSettingTest2() throws Exception {
    SpaceNotificationSetting expectedResponse =
        SpaceNotificationSetting.newBuilder()
            .setName(SpaceNotificationSettingName.of("[USER]", "[SPACE]").toString())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-8145/spaces/space-8145/spaceNotificationSetting";

    SpaceNotificationSetting actualResponse = client.getSpaceNotificationSetting(name);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void getSpaceNotificationSettingExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-8145/spaces/space-8145/spaceNotificationSetting";
      client.getSpaceNotificationSetting(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateSpaceNotificationSettingTest() throws Exception {
    SpaceNotificationSetting expectedResponse =
        SpaceNotificationSetting.newBuilder()
            .setName(SpaceNotificationSettingName.of("[USER]", "[SPACE]").toString())
            .build();
    mockService.addResponse(expectedResponse);

    SpaceNotificationSetting spaceNotificationSetting =
        SpaceNotificationSetting.newBuilder()
            .setName(SpaceNotificationSettingName.of("[USER]", "[SPACE]").toString())
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    SpaceNotificationSetting actualResponse =
        client.updateSpaceNotificationSetting(spaceNotificationSetting, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateSpaceNotificationSettingExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SpaceNotificationSetting spaceNotificationSetting =
          SpaceNotificationSetting.newBuilder()
              .setName(SpaceNotificationSettingName.of("[USER]", "[SPACE]").toString())
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateSpaceNotificationSetting(spaceNotificationSetting, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createSectionTest() throws Exception {
    Section expectedResponse =
        Section.newBuilder()
            .setName(SectionName.of("[USER]", "[SECTION]").toString())
            .setDisplayName("displayName1714148973")
            .setSortOrder(-374296211)
            .build();
    mockService.addResponse(expectedResponse);

    UserName parent = UserName.of("[USER]");
    Section section = Section.newBuilder().build();

    Section actualResponse = client.createSection(parent, section);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createSectionExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      UserName parent = UserName.of("[USER]");
      Section section = Section.newBuilder().build();
      client.createSection(parent, section);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void createSectionTest2() throws Exception {
    Section expectedResponse =
        Section.newBuilder()
            .setName(SectionName.of("[USER]", "[SECTION]").toString())
            .setDisplayName("displayName1714148973")
            .setSortOrder(-374296211)
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "users/user-1015";
    Section section = Section.newBuilder().build();

    Section actualResponse = client.createSection(parent, section);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void createSectionExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "users/user-1015";
      Section section = Section.newBuilder().build();
      client.createSection(parent, section);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteSectionTest() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    SectionName name = SectionName.of("[USER]", "[SECTION]");

    client.deleteSection(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteSectionExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SectionName name = SectionName.of("[USER]", "[SECTION]");
      client.deleteSection(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void deleteSectionTest2() throws Exception {
    Empty expectedResponse = Empty.newBuilder().build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-6096/sections/section-6096";

    client.deleteSection(name);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void deleteSectionExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-6096/sections/section-6096";
      client.deleteSection(name);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void updateSectionTest() throws Exception {
    Section expectedResponse =
        Section.newBuilder()
            .setName(SectionName.of("[USER]", "[SECTION]").toString())
            .setDisplayName("displayName1714148973")
            .setSortOrder(-374296211)
            .build();
    mockService.addResponse(expectedResponse);

    Section section =
        Section.newBuilder()
            .setName(SectionName.of("[USER]", "[SECTION]").toString())
            .setDisplayName("displayName1714148973")
            .setSortOrder(-374296211)
            .build();
    FieldMask updateMask = FieldMask.newBuilder().build();

    Section actualResponse = client.updateSection(section, updateMask);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void updateSectionExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      Section section =
          Section.newBuilder()
              .setName(SectionName.of("[USER]", "[SECTION]").toString())
              .setDisplayName("displayName1714148973")
              .setSortOrder(-374296211)
              .build();
      FieldMask updateMask = FieldMask.newBuilder().build();
      client.updateSection(section, updateMask);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSectionsTest() throws Exception {
    Section responsesElement = Section.newBuilder().build();
    ListSectionsResponse expectedResponse =
        ListSectionsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSections(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    UserName parent = UserName.of("[USER]");

    ListSectionsPagedResponse pagedListResponse = client.listSections(parent);

    List<Section> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSectionsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSectionsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      UserName parent = UserName.of("[USER]");
      client.listSections(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSectionsTest2() throws Exception {
    Section responsesElement = Section.newBuilder().build();
    ListSectionsResponse expectedResponse =
        ListSectionsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSections(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "users/user-1015";

    ListSectionsPagedResponse pagedListResponse = client.listSections(parent);

    List<Section> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSectionsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSectionsExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "users/user-1015";
      client.listSections(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void positionSectionTest() throws Exception {
    PositionSectionResponse expectedResponse =
        PositionSectionResponse.newBuilder().setSection(Section.newBuilder().build()).build();
    mockService.addResponse(expectedResponse);

    PositionSectionRequest request =
        PositionSectionRequest.newBuilder()
            .setName(SectionName.of("[USER]", "[SECTION]").toString())
            .build();

    PositionSectionResponse actualResponse = client.positionSection(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void positionSectionExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      PositionSectionRequest request =
          PositionSectionRequest.newBuilder()
              .setName(SectionName.of("[USER]", "[SECTION]").toString())
              .build();
      client.positionSection(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSectionItemsTest() throws Exception {
    SectionItem responsesElement = SectionItem.newBuilder().build();
    ListSectionItemsResponse expectedResponse =
        ListSectionItemsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSectionItems(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    SectionName parent = SectionName.of("[USER]", "[SECTION]");

    ListSectionItemsPagedResponse pagedListResponse = client.listSectionItems(parent);

    List<SectionItem> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSectionItemsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSectionItemsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SectionName parent = SectionName.of("[USER]", "[SECTION]");
      client.listSectionItems(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void listSectionItemsTest2() throws Exception {
    SectionItem responsesElement = SectionItem.newBuilder().build();
    ListSectionItemsResponse expectedResponse =
        ListSectionItemsResponse.newBuilder()
            .setNextPageToken("")
            .addAllSectionItems(Arrays.asList(responsesElement))
            .build();
    mockService.addResponse(expectedResponse);

    String parent = "users/user-9889/sections/section-9889";

    ListSectionItemsPagedResponse pagedListResponse = client.listSectionItems(parent);

    List<SectionItem> resources = Lists.newArrayList(pagedListResponse.iterateAll());

    Assert.assertEquals(1, resources.size());
    Assert.assertEquals(expectedResponse.getSectionItemsList().get(0), resources.get(0));

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void listSectionItemsExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String parent = "users/user-9889/sections/section-9889";
      client.listSectionItems(parent);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void moveSectionItemTest() throws Exception {
    MoveSectionItemResponse expectedResponse =
        MoveSectionItemResponse.newBuilder()
            .setSectionItem(SectionItem.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SectionItemName name = SectionItemName.of("[USER]", "[SECTION]", "[ITEM]");
    SectionName targetSection = SectionName.of("[USER]", "[SECTION]");

    MoveSectionItemResponse actualResponse = client.moveSectionItem(name, targetSection);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void moveSectionItemExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SectionItemName name = SectionItemName.of("[USER]", "[SECTION]", "[ITEM]");
      SectionName targetSection = SectionName.of("[USER]", "[SECTION]");
      client.moveSectionItem(name, targetSection);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void moveSectionItemTest2() throws Exception {
    MoveSectionItemResponse expectedResponse =
        MoveSectionItemResponse.newBuilder()
            .setSectionItem(SectionItem.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    SectionItemName name = SectionItemName.of("[USER]", "[SECTION]", "[ITEM]");
    String targetSection = "targetSection-20778988";

    MoveSectionItemResponse actualResponse = client.moveSectionItem(name, targetSection);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void moveSectionItemExceptionTest2() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      SectionItemName name = SectionItemName.of("[USER]", "[SECTION]", "[ITEM]");
      String targetSection = "targetSection-20778988";
      client.moveSectionItem(name, targetSection);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void moveSectionItemTest3() throws Exception {
    MoveSectionItemResponse expectedResponse =
        MoveSectionItemResponse.newBuilder()
            .setSectionItem(SectionItem.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-3436/sections/section-3436/items/item-3436";
    SectionName targetSection = SectionName.of("[USER]", "[SECTION]");

    MoveSectionItemResponse actualResponse = client.moveSectionItem(name, targetSection);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void moveSectionItemExceptionTest3() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-3436/sections/section-3436/items/item-3436";
      SectionName targetSection = SectionName.of("[USER]", "[SECTION]");
      client.moveSectionItem(name, targetSection);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void moveSectionItemTest4() throws Exception {
    MoveSectionItemResponse expectedResponse =
        MoveSectionItemResponse.newBuilder()
            .setSectionItem(SectionItem.newBuilder().build())
            .build();
    mockService.addResponse(expectedResponse);

    String name = "users/user-3436/sections/section-3436/items/item-3436";
    String targetSection = "targetSection-20778988";

    MoveSectionItemResponse actualResponse = client.moveSectionItem(name, targetSection);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void moveSectionItemExceptionTest4() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      String name = "users/user-3436/sections/section-3436/items/item-3436";
      String targetSection = "targetSection-20778988";
      client.moveSectionItem(name, targetSection);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }

  @Test
  public void replaceMessageCardsTest() throws Exception {
    ReplaceMessageCardsResponse expectedResponse = ReplaceMessageCardsResponse.newBuilder().build();
    mockService.addResponse(expectedResponse);

    ReplaceMessageCardsRequest request =
        ReplaceMessageCardsRequest.newBuilder()
            .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
            .addAllCardsV2(new ArrayList<CardWithId>())
            .build();

    ReplaceMessageCardsResponse actualResponse = client.replaceMessageCards(request);
    Assert.assertEquals(expectedResponse, actualResponse);

    List<String> actualRequests = mockService.getRequestPaths();
    Assert.assertEquals(1, actualRequests.size());

    String apiClientHeaderKey =
        mockService
            .getRequestHeaders()
            .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
            .iterator()
            .next();
    Assert.assertTrue(
        GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
            .matcher(apiClientHeaderKey)
            .matches());
  }

  @Test
  public void replaceMessageCardsExceptionTest() throws Exception {
    ApiException exception =
        ApiExceptionFactory.createException(
            new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
    mockService.addException(exception);

    try {
      ReplaceMessageCardsRequest request =
          ReplaceMessageCardsRequest.newBuilder()
              .setName(MessageName.of("[SPACE]", "[MESSAGE]").toString())
              .addAllCardsV2(new ArrayList<CardWithId>())
              .build();
      client.replaceMessageCards(request);
      Assert.fail("No exception raised");
    } catch (InvalidArgumentException e) {
      // Expected exception.
    }
  }
}