• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.dialogflow.v2;
18 
19 import static com.google.cloud.dialogflow.v2.EntityTypesClient.ListEntityTypesPagedResponse;
20 import static com.google.cloud.dialogflow.v2.EntityTypesClient.ListLocationsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.cloud.location.GetLocationRequest;
31 import com.google.cloud.location.ListLocationsRequest;
32 import com.google.cloud.location.ListLocationsResponse;
33 import com.google.cloud.location.Location;
34 import com.google.common.collect.Lists;
35 import com.google.longrunning.Operation;
36 import com.google.protobuf.AbstractMessage;
37 import com.google.protobuf.Any;
38 import com.google.protobuf.Empty;
39 import com.google.protobuf.FieldMask;
40 import io.grpc.StatusRuntimeException;
41 import java.io.IOException;
42 import java.util.ArrayList;
43 import java.util.Arrays;
44 import java.util.HashMap;
45 import java.util.List;
46 import java.util.UUID;
47 import java.util.concurrent.ExecutionException;
48 import javax.annotation.Generated;
49 import org.junit.After;
50 import org.junit.AfterClass;
51 import org.junit.Assert;
52 import org.junit.Before;
53 import org.junit.BeforeClass;
54 import org.junit.Test;
55 
56 @Generated("by gapic-generator-java")
57 public class EntityTypesClientTest {
58   private static MockEntityTypes mockEntityTypes;
59   private static MockLocations mockLocations;
60   private static MockServiceHelper mockServiceHelper;
61   private LocalChannelProvider channelProvider;
62   private EntityTypesClient client;
63 
64   @BeforeClass
startStaticServer()65   public static void startStaticServer() {
66     mockEntityTypes = new MockEntityTypes();
67     mockLocations = new MockLocations();
68     mockServiceHelper =
69         new MockServiceHelper(
70             UUID.randomUUID().toString(),
71             Arrays.<MockGrpcService>asList(mockEntityTypes, mockLocations));
72     mockServiceHelper.start();
73   }
74 
75   @AfterClass
stopServer()76   public static void stopServer() {
77     mockServiceHelper.stop();
78   }
79 
80   @Before
setUp()81   public void setUp() throws IOException {
82     mockServiceHelper.reset();
83     channelProvider = mockServiceHelper.createChannelProvider();
84     EntityTypesSettings settings =
85         EntityTypesSettings.newBuilder()
86             .setTransportChannelProvider(channelProvider)
87             .setCredentialsProvider(NoCredentialsProvider.create())
88             .build();
89     client = EntityTypesClient.create(settings);
90   }
91 
92   @After
tearDown()93   public void tearDown() throws Exception {
94     client.close();
95   }
96 
97   @Test
listEntityTypesTest()98   public void listEntityTypesTest() throws Exception {
99     EntityType responsesElement = EntityType.newBuilder().build();
100     ListEntityTypesResponse expectedResponse =
101         ListEntityTypesResponse.newBuilder()
102             .setNextPageToken("")
103             .addAllEntityTypes(Arrays.asList(responsesElement))
104             .build();
105     mockEntityTypes.addResponse(expectedResponse);
106 
107     AgentName parent = AgentName.ofProjectName("[PROJECT]");
108 
109     ListEntityTypesPagedResponse pagedListResponse = client.listEntityTypes(parent);
110 
111     List<EntityType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
112 
113     Assert.assertEquals(1, resources.size());
114     Assert.assertEquals(expectedResponse.getEntityTypesList().get(0), resources.get(0));
115 
116     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
117     Assert.assertEquals(1, actualRequests.size());
118     ListEntityTypesRequest actualRequest = ((ListEntityTypesRequest) actualRequests.get(0));
119 
120     Assert.assertEquals(parent.toString(), actualRequest.getParent());
121     Assert.assertTrue(
122         channelProvider.isHeaderSent(
123             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
124             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
125   }
126 
127   @Test
listEntityTypesExceptionTest()128   public void listEntityTypesExceptionTest() throws Exception {
129     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
130     mockEntityTypes.addException(exception);
131 
132     try {
133       AgentName parent = AgentName.ofProjectName("[PROJECT]");
134       client.listEntityTypes(parent);
135       Assert.fail("No exception raised");
136     } catch (InvalidArgumentException e) {
137       // Expected exception.
138     }
139   }
140 
141   @Test
listEntityTypesTest2()142   public void listEntityTypesTest2() throws Exception {
143     EntityType responsesElement = EntityType.newBuilder().build();
144     ListEntityTypesResponse expectedResponse =
145         ListEntityTypesResponse.newBuilder()
146             .setNextPageToken("")
147             .addAllEntityTypes(Arrays.asList(responsesElement))
148             .build();
149     mockEntityTypes.addResponse(expectedResponse);
150 
151     String parent = "parent-995424086";
152 
153     ListEntityTypesPagedResponse pagedListResponse = client.listEntityTypes(parent);
154 
155     List<EntityType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
156 
157     Assert.assertEquals(1, resources.size());
158     Assert.assertEquals(expectedResponse.getEntityTypesList().get(0), resources.get(0));
159 
160     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
161     Assert.assertEquals(1, actualRequests.size());
162     ListEntityTypesRequest actualRequest = ((ListEntityTypesRequest) actualRequests.get(0));
163 
164     Assert.assertEquals(parent, actualRequest.getParent());
165     Assert.assertTrue(
166         channelProvider.isHeaderSent(
167             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
168             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
169   }
170 
171   @Test
listEntityTypesExceptionTest2()172   public void listEntityTypesExceptionTest2() throws Exception {
173     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
174     mockEntityTypes.addException(exception);
175 
176     try {
177       String parent = "parent-995424086";
178       client.listEntityTypes(parent);
179       Assert.fail("No exception raised");
180     } catch (InvalidArgumentException e) {
181       // Expected exception.
182     }
183   }
184 
185   @Test
listEntityTypesTest3()186   public void listEntityTypesTest3() throws Exception {
187     EntityType responsesElement = EntityType.newBuilder().build();
188     ListEntityTypesResponse expectedResponse =
189         ListEntityTypesResponse.newBuilder()
190             .setNextPageToken("")
191             .addAllEntityTypes(Arrays.asList(responsesElement))
192             .build();
193     mockEntityTypes.addResponse(expectedResponse);
194 
195     AgentName parent = AgentName.ofProjectName("[PROJECT]");
196     String languageCode = "languageCode-2092349083";
197 
198     ListEntityTypesPagedResponse pagedListResponse = client.listEntityTypes(parent, languageCode);
199 
200     List<EntityType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
201 
202     Assert.assertEquals(1, resources.size());
203     Assert.assertEquals(expectedResponse.getEntityTypesList().get(0), resources.get(0));
204 
205     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
206     Assert.assertEquals(1, actualRequests.size());
207     ListEntityTypesRequest actualRequest = ((ListEntityTypesRequest) actualRequests.get(0));
208 
209     Assert.assertEquals(parent.toString(), actualRequest.getParent());
210     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
211     Assert.assertTrue(
212         channelProvider.isHeaderSent(
213             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
214             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
215   }
216 
217   @Test
listEntityTypesExceptionTest3()218   public void listEntityTypesExceptionTest3() throws Exception {
219     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
220     mockEntityTypes.addException(exception);
221 
222     try {
223       AgentName parent = AgentName.ofProjectName("[PROJECT]");
224       String languageCode = "languageCode-2092349083";
225       client.listEntityTypes(parent, languageCode);
226       Assert.fail("No exception raised");
227     } catch (InvalidArgumentException e) {
228       // Expected exception.
229     }
230   }
231 
232   @Test
listEntityTypesTest4()233   public void listEntityTypesTest4() throws Exception {
234     EntityType responsesElement = EntityType.newBuilder().build();
235     ListEntityTypesResponse expectedResponse =
236         ListEntityTypesResponse.newBuilder()
237             .setNextPageToken("")
238             .addAllEntityTypes(Arrays.asList(responsesElement))
239             .build();
240     mockEntityTypes.addResponse(expectedResponse);
241 
242     String parent = "parent-995424086";
243     String languageCode = "languageCode-2092349083";
244 
245     ListEntityTypesPagedResponse pagedListResponse = client.listEntityTypes(parent, languageCode);
246 
247     List<EntityType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
248 
249     Assert.assertEquals(1, resources.size());
250     Assert.assertEquals(expectedResponse.getEntityTypesList().get(0), resources.get(0));
251 
252     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
253     Assert.assertEquals(1, actualRequests.size());
254     ListEntityTypesRequest actualRequest = ((ListEntityTypesRequest) actualRequests.get(0));
255 
256     Assert.assertEquals(parent, actualRequest.getParent());
257     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
258     Assert.assertTrue(
259         channelProvider.isHeaderSent(
260             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
261             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
262   }
263 
264   @Test
listEntityTypesExceptionTest4()265   public void listEntityTypesExceptionTest4() throws Exception {
266     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
267     mockEntityTypes.addException(exception);
268 
269     try {
270       String parent = "parent-995424086";
271       String languageCode = "languageCode-2092349083";
272       client.listEntityTypes(parent, languageCode);
273       Assert.fail("No exception raised");
274     } catch (InvalidArgumentException e) {
275       // Expected exception.
276     }
277   }
278 
279   @Test
getEntityTypeTest()280   public void getEntityTypeTest() throws Exception {
281     EntityType expectedResponse =
282         EntityType.newBuilder()
283             .setName(
284                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
285             .setDisplayName("displayName1714148973")
286             .addAllEntities(new ArrayList<EntityType.Entity>())
287             .setEnableFuzzyExtraction(true)
288             .build();
289     mockEntityTypes.addResponse(expectedResponse);
290 
291     EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
292 
293     EntityType actualResponse = client.getEntityType(name);
294     Assert.assertEquals(expectedResponse, actualResponse);
295 
296     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
297     Assert.assertEquals(1, actualRequests.size());
298     GetEntityTypeRequest actualRequest = ((GetEntityTypeRequest) actualRequests.get(0));
299 
300     Assert.assertEquals(name.toString(), actualRequest.getName());
301     Assert.assertTrue(
302         channelProvider.isHeaderSent(
303             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
304             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
305   }
306 
307   @Test
getEntityTypeExceptionTest()308   public void getEntityTypeExceptionTest() throws Exception {
309     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
310     mockEntityTypes.addException(exception);
311 
312     try {
313       EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
314       client.getEntityType(name);
315       Assert.fail("No exception raised");
316     } catch (InvalidArgumentException e) {
317       // Expected exception.
318     }
319   }
320 
321   @Test
getEntityTypeTest2()322   public void getEntityTypeTest2() throws Exception {
323     EntityType expectedResponse =
324         EntityType.newBuilder()
325             .setName(
326                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
327             .setDisplayName("displayName1714148973")
328             .addAllEntities(new ArrayList<EntityType.Entity>())
329             .setEnableFuzzyExtraction(true)
330             .build();
331     mockEntityTypes.addResponse(expectedResponse);
332 
333     String name = "name3373707";
334 
335     EntityType actualResponse = client.getEntityType(name);
336     Assert.assertEquals(expectedResponse, actualResponse);
337 
338     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
339     Assert.assertEquals(1, actualRequests.size());
340     GetEntityTypeRequest actualRequest = ((GetEntityTypeRequest) actualRequests.get(0));
341 
342     Assert.assertEquals(name, actualRequest.getName());
343     Assert.assertTrue(
344         channelProvider.isHeaderSent(
345             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
346             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
347   }
348 
349   @Test
getEntityTypeExceptionTest2()350   public void getEntityTypeExceptionTest2() throws Exception {
351     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
352     mockEntityTypes.addException(exception);
353 
354     try {
355       String name = "name3373707";
356       client.getEntityType(name);
357       Assert.fail("No exception raised");
358     } catch (InvalidArgumentException e) {
359       // Expected exception.
360     }
361   }
362 
363   @Test
getEntityTypeTest3()364   public void getEntityTypeTest3() throws Exception {
365     EntityType expectedResponse =
366         EntityType.newBuilder()
367             .setName(
368                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
369             .setDisplayName("displayName1714148973")
370             .addAllEntities(new ArrayList<EntityType.Entity>())
371             .setEnableFuzzyExtraction(true)
372             .build();
373     mockEntityTypes.addResponse(expectedResponse);
374 
375     EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
376     String languageCode = "languageCode-2092349083";
377 
378     EntityType actualResponse = client.getEntityType(name, languageCode);
379     Assert.assertEquals(expectedResponse, actualResponse);
380 
381     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
382     Assert.assertEquals(1, actualRequests.size());
383     GetEntityTypeRequest actualRequest = ((GetEntityTypeRequest) actualRequests.get(0));
384 
385     Assert.assertEquals(name.toString(), actualRequest.getName());
386     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
387     Assert.assertTrue(
388         channelProvider.isHeaderSent(
389             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
390             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
391   }
392 
393   @Test
getEntityTypeExceptionTest3()394   public void getEntityTypeExceptionTest3() throws Exception {
395     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
396     mockEntityTypes.addException(exception);
397 
398     try {
399       EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
400       String languageCode = "languageCode-2092349083";
401       client.getEntityType(name, languageCode);
402       Assert.fail("No exception raised");
403     } catch (InvalidArgumentException e) {
404       // Expected exception.
405     }
406   }
407 
408   @Test
getEntityTypeTest4()409   public void getEntityTypeTest4() throws Exception {
410     EntityType expectedResponse =
411         EntityType.newBuilder()
412             .setName(
413                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
414             .setDisplayName("displayName1714148973")
415             .addAllEntities(new ArrayList<EntityType.Entity>())
416             .setEnableFuzzyExtraction(true)
417             .build();
418     mockEntityTypes.addResponse(expectedResponse);
419 
420     String name = "name3373707";
421     String languageCode = "languageCode-2092349083";
422 
423     EntityType actualResponse = client.getEntityType(name, languageCode);
424     Assert.assertEquals(expectedResponse, actualResponse);
425 
426     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
427     Assert.assertEquals(1, actualRequests.size());
428     GetEntityTypeRequest actualRequest = ((GetEntityTypeRequest) actualRequests.get(0));
429 
430     Assert.assertEquals(name, actualRequest.getName());
431     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
432     Assert.assertTrue(
433         channelProvider.isHeaderSent(
434             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
435             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
436   }
437 
438   @Test
getEntityTypeExceptionTest4()439   public void getEntityTypeExceptionTest4() throws Exception {
440     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
441     mockEntityTypes.addException(exception);
442 
443     try {
444       String name = "name3373707";
445       String languageCode = "languageCode-2092349083";
446       client.getEntityType(name, languageCode);
447       Assert.fail("No exception raised");
448     } catch (InvalidArgumentException e) {
449       // Expected exception.
450     }
451   }
452 
453   @Test
createEntityTypeTest()454   public void createEntityTypeTest() throws Exception {
455     EntityType expectedResponse =
456         EntityType.newBuilder()
457             .setName(
458                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
459             .setDisplayName("displayName1714148973")
460             .addAllEntities(new ArrayList<EntityType.Entity>())
461             .setEnableFuzzyExtraction(true)
462             .build();
463     mockEntityTypes.addResponse(expectedResponse);
464 
465     AgentName parent = AgentName.ofProjectName("[PROJECT]");
466     EntityType entityType = EntityType.newBuilder().build();
467 
468     EntityType actualResponse = client.createEntityType(parent, entityType);
469     Assert.assertEquals(expectedResponse, actualResponse);
470 
471     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
472     Assert.assertEquals(1, actualRequests.size());
473     CreateEntityTypeRequest actualRequest = ((CreateEntityTypeRequest) actualRequests.get(0));
474 
475     Assert.assertEquals(parent.toString(), actualRequest.getParent());
476     Assert.assertEquals(entityType, actualRequest.getEntityType());
477     Assert.assertTrue(
478         channelProvider.isHeaderSent(
479             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
480             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
481   }
482 
483   @Test
createEntityTypeExceptionTest()484   public void createEntityTypeExceptionTest() throws Exception {
485     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
486     mockEntityTypes.addException(exception);
487 
488     try {
489       AgentName parent = AgentName.ofProjectName("[PROJECT]");
490       EntityType entityType = EntityType.newBuilder().build();
491       client.createEntityType(parent, entityType);
492       Assert.fail("No exception raised");
493     } catch (InvalidArgumentException e) {
494       // Expected exception.
495     }
496   }
497 
498   @Test
createEntityTypeTest2()499   public void createEntityTypeTest2() throws Exception {
500     EntityType expectedResponse =
501         EntityType.newBuilder()
502             .setName(
503                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
504             .setDisplayName("displayName1714148973")
505             .addAllEntities(new ArrayList<EntityType.Entity>())
506             .setEnableFuzzyExtraction(true)
507             .build();
508     mockEntityTypes.addResponse(expectedResponse);
509 
510     String parent = "parent-995424086";
511     EntityType entityType = EntityType.newBuilder().build();
512 
513     EntityType actualResponse = client.createEntityType(parent, entityType);
514     Assert.assertEquals(expectedResponse, actualResponse);
515 
516     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
517     Assert.assertEquals(1, actualRequests.size());
518     CreateEntityTypeRequest actualRequest = ((CreateEntityTypeRequest) actualRequests.get(0));
519 
520     Assert.assertEquals(parent, actualRequest.getParent());
521     Assert.assertEquals(entityType, actualRequest.getEntityType());
522     Assert.assertTrue(
523         channelProvider.isHeaderSent(
524             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
525             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
526   }
527 
528   @Test
createEntityTypeExceptionTest2()529   public void createEntityTypeExceptionTest2() throws Exception {
530     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
531     mockEntityTypes.addException(exception);
532 
533     try {
534       String parent = "parent-995424086";
535       EntityType entityType = EntityType.newBuilder().build();
536       client.createEntityType(parent, entityType);
537       Assert.fail("No exception raised");
538     } catch (InvalidArgumentException e) {
539       // Expected exception.
540     }
541   }
542 
543   @Test
createEntityTypeTest3()544   public void createEntityTypeTest3() throws Exception {
545     EntityType expectedResponse =
546         EntityType.newBuilder()
547             .setName(
548                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
549             .setDisplayName("displayName1714148973")
550             .addAllEntities(new ArrayList<EntityType.Entity>())
551             .setEnableFuzzyExtraction(true)
552             .build();
553     mockEntityTypes.addResponse(expectedResponse);
554 
555     AgentName parent = AgentName.ofProjectName("[PROJECT]");
556     EntityType entityType = EntityType.newBuilder().build();
557     String languageCode = "languageCode-2092349083";
558 
559     EntityType actualResponse = client.createEntityType(parent, entityType, languageCode);
560     Assert.assertEquals(expectedResponse, actualResponse);
561 
562     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
563     Assert.assertEquals(1, actualRequests.size());
564     CreateEntityTypeRequest actualRequest = ((CreateEntityTypeRequest) actualRequests.get(0));
565 
566     Assert.assertEquals(parent.toString(), actualRequest.getParent());
567     Assert.assertEquals(entityType, actualRequest.getEntityType());
568     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
569     Assert.assertTrue(
570         channelProvider.isHeaderSent(
571             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
572             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
573   }
574 
575   @Test
createEntityTypeExceptionTest3()576   public void createEntityTypeExceptionTest3() throws Exception {
577     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
578     mockEntityTypes.addException(exception);
579 
580     try {
581       AgentName parent = AgentName.ofProjectName("[PROJECT]");
582       EntityType entityType = EntityType.newBuilder().build();
583       String languageCode = "languageCode-2092349083";
584       client.createEntityType(parent, entityType, languageCode);
585       Assert.fail("No exception raised");
586     } catch (InvalidArgumentException e) {
587       // Expected exception.
588     }
589   }
590 
591   @Test
createEntityTypeTest4()592   public void createEntityTypeTest4() throws Exception {
593     EntityType expectedResponse =
594         EntityType.newBuilder()
595             .setName(
596                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
597             .setDisplayName("displayName1714148973")
598             .addAllEntities(new ArrayList<EntityType.Entity>())
599             .setEnableFuzzyExtraction(true)
600             .build();
601     mockEntityTypes.addResponse(expectedResponse);
602 
603     String parent = "parent-995424086";
604     EntityType entityType = EntityType.newBuilder().build();
605     String languageCode = "languageCode-2092349083";
606 
607     EntityType actualResponse = client.createEntityType(parent, entityType, languageCode);
608     Assert.assertEquals(expectedResponse, actualResponse);
609 
610     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
611     Assert.assertEquals(1, actualRequests.size());
612     CreateEntityTypeRequest actualRequest = ((CreateEntityTypeRequest) actualRequests.get(0));
613 
614     Assert.assertEquals(parent, actualRequest.getParent());
615     Assert.assertEquals(entityType, actualRequest.getEntityType());
616     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
617     Assert.assertTrue(
618         channelProvider.isHeaderSent(
619             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
620             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
621   }
622 
623   @Test
createEntityTypeExceptionTest4()624   public void createEntityTypeExceptionTest4() throws Exception {
625     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
626     mockEntityTypes.addException(exception);
627 
628     try {
629       String parent = "parent-995424086";
630       EntityType entityType = EntityType.newBuilder().build();
631       String languageCode = "languageCode-2092349083";
632       client.createEntityType(parent, entityType, languageCode);
633       Assert.fail("No exception raised");
634     } catch (InvalidArgumentException e) {
635       // Expected exception.
636     }
637   }
638 
639   @Test
updateEntityTypeTest()640   public void updateEntityTypeTest() throws Exception {
641     EntityType expectedResponse =
642         EntityType.newBuilder()
643             .setName(
644                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
645             .setDisplayName("displayName1714148973")
646             .addAllEntities(new ArrayList<EntityType.Entity>())
647             .setEnableFuzzyExtraction(true)
648             .build();
649     mockEntityTypes.addResponse(expectedResponse);
650 
651     EntityType entityType = EntityType.newBuilder().build();
652 
653     EntityType actualResponse = client.updateEntityType(entityType);
654     Assert.assertEquals(expectedResponse, actualResponse);
655 
656     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
657     Assert.assertEquals(1, actualRequests.size());
658     UpdateEntityTypeRequest actualRequest = ((UpdateEntityTypeRequest) actualRequests.get(0));
659 
660     Assert.assertEquals(entityType, actualRequest.getEntityType());
661     Assert.assertTrue(
662         channelProvider.isHeaderSent(
663             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
664             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
665   }
666 
667   @Test
updateEntityTypeExceptionTest()668   public void updateEntityTypeExceptionTest() throws Exception {
669     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
670     mockEntityTypes.addException(exception);
671 
672     try {
673       EntityType entityType = EntityType.newBuilder().build();
674       client.updateEntityType(entityType);
675       Assert.fail("No exception raised");
676     } catch (InvalidArgumentException e) {
677       // Expected exception.
678     }
679   }
680 
681   @Test
updateEntityTypeTest2()682   public void updateEntityTypeTest2() throws Exception {
683     EntityType expectedResponse =
684         EntityType.newBuilder()
685             .setName(
686                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
687             .setDisplayName("displayName1714148973")
688             .addAllEntities(new ArrayList<EntityType.Entity>())
689             .setEnableFuzzyExtraction(true)
690             .build();
691     mockEntityTypes.addResponse(expectedResponse);
692 
693     EntityType entityType = EntityType.newBuilder().build();
694     String languageCode = "languageCode-2092349083";
695 
696     EntityType actualResponse = client.updateEntityType(entityType, languageCode);
697     Assert.assertEquals(expectedResponse, actualResponse);
698 
699     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
700     Assert.assertEquals(1, actualRequests.size());
701     UpdateEntityTypeRequest actualRequest = ((UpdateEntityTypeRequest) actualRequests.get(0));
702 
703     Assert.assertEquals(entityType, actualRequest.getEntityType());
704     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
705     Assert.assertTrue(
706         channelProvider.isHeaderSent(
707             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
708             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
709   }
710 
711   @Test
updateEntityTypeExceptionTest2()712   public void updateEntityTypeExceptionTest2() throws Exception {
713     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
714     mockEntityTypes.addException(exception);
715 
716     try {
717       EntityType entityType = EntityType.newBuilder().build();
718       String languageCode = "languageCode-2092349083";
719       client.updateEntityType(entityType, languageCode);
720       Assert.fail("No exception raised");
721     } catch (InvalidArgumentException e) {
722       // Expected exception.
723     }
724   }
725 
726   @Test
deleteEntityTypeTest()727   public void deleteEntityTypeTest() throws Exception {
728     Empty expectedResponse = Empty.newBuilder().build();
729     mockEntityTypes.addResponse(expectedResponse);
730 
731     EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
732 
733     client.deleteEntityType(name);
734 
735     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
736     Assert.assertEquals(1, actualRequests.size());
737     DeleteEntityTypeRequest actualRequest = ((DeleteEntityTypeRequest) actualRequests.get(0));
738 
739     Assert.assertEquals(name.toString(), actualRequest.getName());
740     Assert.assertTrue(
741         channelProvider.isHeaderSent(
742             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
743             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
744   }
745 
746   @Test
deleteEntityTypeExceptionTest()747   public void deleteEntityTypeExceptionTest() throws Exception {
748     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
749     mockEntityTypes.addException(exception);
750 
751     try {
752       EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
753       client.deleteEntityType(name);
754       Assert.fail("No exception raised");
755     } catch (InvalidArgumentException e) {
756       // Expected exception.
757     }
758   }
759 
760   @Test
deleteEntityTypeTest2()761   public void deleteEntityTypeTest2() throws Exception {
762     Empty expectedResponse = Empty.newBuilder().build();
763     mockEntityTypes.addResponse(expectedResponse);
764 
765     String name = "name3373707";
766 
767     client.deleteEntityType(name);
768 
769     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
770     Assert.assertEquals(1, actualRequests.size());
771     DeleteEntityTypeRequest actualRequest = ((DeleteEntityTypeRequest) actualRequests.get(0));
772 
773     Assert.assertEquals(name, actualRequest.getName());
774     Assert.assertTrue(
775         channelProvider.isHeaderSent(
776             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
777             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
778   }
779 
780   @Test
deleteEntityTypeExceptionTest2()781   public void deleteEntityTypeExceptionTest2() throws Exception {
782     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
783     mockEntityTypes.addException(exception);
784 
785     try {
786       String name = "name3373707";
787       client.deleteEntityType(name);
788       Assert.fail("No exception raised");
789     } catch (InvalidArgumentException e) {
790       // Expected exception.
791     }
792   }
793 
794   @Test
batchUpdateEntityTypesTest()795   public void batchUpdateEntityTypesTest() throws Exception {
796     BatchUpdateEntityTypesResponse expectedResponse =
797         BatchUpdateEntityTypesResponse.newBuilder()
798             .addAllEntityTypes(new ArrayList<EntityType>())
799             .build();
800     Operation resultOperation =
801         Operation.newBuilder()
802             .setName("batchUpdateEntityTypesTest")
803             .setDone(true)
804             .setResponse(Any.pack(expectedResponse))
805             .build();
806     mockEntityTypes.addResponse(resultOperation);
807 
808     BatchUpdateEntityTypesRequest request =
809         BatchUpdateEntityTypesRequest.newBuilder()
810             .setParent(AgentName.ofProjectName("[PROJECT]").toString())
811             .setLanguageCode("languageCode-2092349083")
812             .setUpdateMask(FieldMask.newBuilder().build())
813             .build();
814 
815     BatchUpdateEntityTypesResponse actualResponse =
816         client.batchUpdateEntityTypesAsync(request).get();
817     Assert.assertEquals(expectedResponse, actualResponse);
818 
819     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
820     Assert.assertEquals(1, actualRequests.size());
821     BatchUpdateEntityTypesRequest actualRequest =
822         ((BatchUpdateEntityTypesRequest) actualRequests.get(0));
823 
824     Assert.assertEquals(request.getParent(), actualRequest.getParent());
825     Assert.assertEquals(request.getEntityTypeBatchUri(), actualRequest.getEntityTypeBatchUri());
826     Assert.assertEquals(
827         request.getEntityTypeBatchInline(), actualRequest.getEntityTypeBatchInline());
828     Assert.assertEquals(request.getLanguageCode(), actualRequest.getLanguageCode());
829     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
830     Assert.assertTrue(
831         channelProvider.isHeaderSent(
832             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
833             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
834   }
835 
836   @Test
batchUpdateEntityTypesExceptionTest()837   public void batchUpdateEntityTypesExceptionTest() throws Exception {
838     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
839     mockEntityTypes.addException(exception);
840 
841     try {
842       BatchUpdateEntityTypesRequest request =
843           BatchUpdateEntityTypesRequest.newBuilder()
844               .setParent(AgentName.ofProjectName("[PROJECT]").toString())
845               .setLanguageCode("languageCode-2092349083")
846               .setUpdateMask(FieldMask.newBuilder().build())
847               .build();
848       client.batchUpdateEntityTypesAsync(request).get();
849       Assert.fail("No exception raised");
850     } catch (ExecutionException e) {
851       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
852       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
853       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
854     }
855   }
856 
857   @Test
batchDeleteEntityTypesTest()858   public void batchDeleteEntityTypesTest() throws Exception {
859     Empty expectedResponse = Empty.newBuilder().build();
860     Operation resultOperation =
861         Operation.newBuilder()
862             .setName("batchDeleteEntityTypesTest")
863             .setDone(true)
864             .setResponse(Any.pack(expectedResponse))
865             .build();
866     mockEntityTypes.addResponse(resultOperation);
867 
868     AgentName parent = AgentName.ofProjectName("[PROJECT]");
869     List<String> entityTypeNames = new ArrayList<>();
870 
871     client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
872 
873     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
874     Assert.assertEquals(1, actualRequests.size());
875     BatchDeleteEntityTypesRequest actualRequest =
876         ((BatchDeleteEntityTypesRequest) actualRequests.get(0));
877 
878     Assert.assertEquals(parent.toString(), actualRequest.getParent());
879     Assert.assertEquals(entityTypeNames, actualRequest.getEntityTypeNamesList());
880     Assert.assertTrue(
881         channelProvider.isHeaderSent(
882             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
883             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
884   }
885 
886   @Test
batchDeleteEntityTypesExceptionTest()887   public void batchDeleteEntityTypesExceptionTest() throws Exception {
888     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
889     mockEntityTypes.addException(exception);
890 
891     try {
892       AgentName parent = AgentName.ofProjectName("[PROJECT]");
893       List<String> entityTypeNames = new ArrayList<>();
894       client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
895       Assert.fail("No exception raised");
896     } catch (ExecutionException e) {
897       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
898       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
899       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
900     }
901   }
902 
903   @Test
batchDeleteEntityTypesTest2()904   public void batchDeleteEntityTypesTest2() throws Exception {
905     Empty expectedResponse = Empty.newBuilder().build();
906     Operation resultOperation =
907         Operation.newBuilder()
908             .setName("batchDeleteEntityTypesTest")
909             .setDone(true)
910             .setResponse(Any.pack(expectedResponse))
911             .build();
912     mockEntityTypes.addResponse(resultOperation);
913 
914     String parent = "parent-995424086";
915     List<String> entityTypeNames = new ArrayList<>();
916 
917     client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
918 
919     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
920     Assert.assertEquals(1, actualRequests.size());
921     BatchDeleteEntityTypesRequest actualRequest =
922         ((BatchDeleteEntityTypesRequest) actualRequests.get(0));
923 
924     Assert.assertEquals(parent, actualRequest.getParent());
925     Assert.assertEquals(entityTypeNames, actualRequest.getEntityTypeNamesList());
926     Assert.assertTrue(
927         channelProvider.isHeaderSent(
928             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
929             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
930   }
931 
932   @Test
batchDeleteEntityTypesExceptionTest2()933   public void batchDeleteEntityTypesExceptionTest2() throws Exception {
934     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
935     mockEntityTypes.addException(exception);
936 
937     try {
938       String parent = "parent-995424086";
939       List<String> entityTypeNames = new ArrayList<>();
940       client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
941       Assert.fail("No exception raised");
942     } catch (ExecutionException e) {
943       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
944       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
945       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
946     }
947   }
948 
949   @Test
batchCreateEntitiesTest()950   public void batchCreateEntitiesTest() throws Exception {
951     Empty expectedResponse = Empty.newBuilder().build();
952     Operation resultOperation =
953         Operation.newBuilder()
954             .setName("batchCreateEntitiesTest")
955             .setDone(true)
956             .setResponse(Any.pack(expectedResponse))
957             .build();
958     mockEntityTypes.addResponse(resultOperation);
959 
960     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
961     List<EntityType.Entity> entities = new ArrayList<>();
962 
963     client.batchCreateEntitiesAsync(parent, entities).get();
964 
965     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
966     Assert.assertEquals(1, actualRequests.size());
967     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
968 
969     Assert.assertEquals(parent.toString(), actualRequest.getParent());
970     Assert.assertEquals(entities, actualRequest.getEntitiesList());
971     Assert.assertTrue(
972         channelProvider.isHeaderSent(
973             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
974             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
975   }
976 
977   @Test
batchCreateEntitiesExceptionTest()978   public void batchCreateEntitiesExceptionTest() throws Exception {
979     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
980     mockEntityTypes.addException(exception);
981 
982     try {
983       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
984       List<EntityType.Entity> entities = new ArrayList<>();
985       client.batchCreateEntitiesAsync(parent, entities).get();
986       Assert.fail("No exception raised");
987     } catch (ExecutionException e) {
988       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
989       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
990       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
991     }
992   }
993 
994   @Test
batchCreateEntitiesTest2()995   public void batchCreateEntitiesTest2() throws Exception {
996     Empty expectedResponse = Empty.newBuilder().build();
997     Operation resultOperation =
998         Operation.newBuilder()
999             .setName("batchCreateEntitiesTest")
1000             .setDone(true)
1001             .setResponse(Any.pack(expectedResponse))
1002             .build();
1003     mockEntityTypes.addResponse(resultOperation);
1004 
1005     String parent = "parent-995424086";
1006     List<EntityType.Entity> entities = new ArrayList<>();
1007 
1008     client.batchCreateEntitiesAsync(parent, entities).get();
1009 
1010     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1011     Assert.assertEquals(1, actualRequests.size());
1012     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
1013 
1014     Assert.assertEquals(parent, actualRequest.getParent());
1015     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1016     Assert.assertTrue(
1017         channelProvider.isHeaderSent(
1018             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1019             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1020   }
1021 
1022   @Test
batchCreateEntitiesExceptionTest2()1023   public void batchCreateEntitiesExceptionTest2() throws Exception {
1024     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1025     mockEntityTypes.addException(exception);
1026 
1027     try {
1028       String parent = "parent-995424086";
1029       List<EntityType.Entity> entities = new ArrayList<>();
1030       client.batchCreateEntitiesAsync(parent, entities).get();
1031       Assert.fail("No exception raised");
1032     } catch (ExecutionException e) {
1033       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1034       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1035       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1036     }
1037   }
1038 
1039   @Test
batchCreateEntitiesTest3()1040   public void batchCreateEntitiesTest3() throws Exception {
1041     Empty expectedResponse = Empty.newBuilder().build();
1042     Operation resultOperation =
1043         Operation.newBuilder()
1044             .setName("batchCreateEntitiesTest")
1045             .setDone(true)
1046             .setResponse(Any.pack(expectedResponse))
1047             .build();
1048     mockEntityTypes.addResponse(resultOperation);
1049 
1050     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1051     List<EntityType.Entity> entities = new ArrayList<>();
1052     String languageCode = "languageCode-2092349083";
1053 
1054     client.batchCreateEntitiesAsync(parent, entities, languageCode).get();
1055 
1056     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1057     Assert.assertEquals(1, actualRequests.size());
1058     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
1059 
1060     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1061     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1062     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1063     Assert.assertTrue(
1064         channelProvider.isHeaderSent(
1065             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1066             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1067   }
1068 
1069   @Test
batchCreateEntitiesExceptionTest3()1070   public void batchCreateEntitiesExceptionTest3() throws Exception {
1071     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1072     mockEntityTypes.addException(exception);
1073 
1074     try {
1075       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1076       List<EntityType.Entity> entities = new ArrayList<>();
1077       String languageCode = "languageCode-2092349083";
1078       client.batchCreateEntitiesAsync(parent, entities, languageCode).get();
1079       Assert.fail("No exception raised");
1080     } catch (ExecutionException e) {
1081       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1082       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1083       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1084     }
1085   }
1086 
1087   @Test
batchCreateEntitiesTest4()1088   public void batchCreateEntitiesTest4() throws Exception {
1089     Empty expectedResponse = Empty.newBuilder().build();
1090     Operation resultOperation =
1091         Operation.newBuilder()
1092             .setName("batchCreateEntitiesTest")
1093             .setDone(true)
1094             .setResponse(Any.pack(expectedResponse))
1095             .build();
1096     mockEntityTypes.addResponse(resultOperation);
1097 
1098     String parent = "parent-995424086";
1099     List<EntityType.Entity> entities = new ArrayList<>();
1100     String languageCode = "languageCode-2092349083";
1101 
1102     client.batchCreateEntitiesAsync(parent, entities, languageCode).get();
1103 
1104     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1105     Assert.assertEquals(1, actualRequests.size());
1106     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
1107 
1108     Assert.assertEquals(parent, actualRequest.getParent());
1109     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1110     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1111     Assert.assertTrue(
1112         channelProvider.isHeaderSent(
1113             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1114             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1115   }
1116 
1117   @Test
batchCreateEntitiesExceptionTest4()1118   public void batchCreateEntitiesExceptionTest4() throws Exception {
1119     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1120     mockEntityTypes.addException(exception);
1121 
1122     try {
1123       String parent = "parent-995424086";
1124       List<EntityType.Entity> entities = new ArrayList<>();
1125       String languageCode = "languageCode-2092349083";
1126       client.batchCreateEntitiesAsync(parent, entities, languageCode).get();
1127       Assert.fail("No exception raised");
1128     } catch (ExecutionException e) {
1129       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1130       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1131       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1132     }
1133   }
1134 
1135   @Test
batchUpdateEntitiesTest()1136   public void batchUpdateEntitiesTest() throws Exception {
1137     Empty expectedResponse = Empty.newBuilder().build();
1138     Operation resultOperation =
1139         Operation.newBuilder()
1140             .setName("batchUpdateEntitiesTest")
1141             .setDone(true)
1142             .setResponse(Any.pack(expectedResponse))
1143             .build();
1144     mockEntityTypes.addResponse(resultOperation);
1145 
1146     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1147     List<EntityType.Entity> entities = new ArrayList<>();
1148 
1149     client.batchUpdateEntitiesAsync(parent, entities).get();
1150 
1151     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1152     Assert.assertEquals(1, actualRequests.size());
1153     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1154 
1155     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1156     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1157     Assert.assertTrue(
1158         channelProvider.isHeaderSent(
1159             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1160             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1161   }
1162 
1163   @Test
batchUpdateEntitiesExceptionTest()1164   public void batchUpdateEntitiesExceptionTest() throws Exception {
1165     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1166     mockEntityTypes.addException(exception);
1167 
1168     try {
1169       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1170       List<EntityType.Entity> entities = new ArrayList<>();
1171       client.batchUpdateEntitiesAsync(parent, entities).get();
1172       Assert.fail("No exception raised");
1173     } catch (ExecutionException e) {
1174       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1175       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1176       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1177     }
1178   }
1179 
1180   @Test
batchUpdateEntitiesTest2()1181   public void batchUpdateEntitiesTest2() throws Exception {
1182     Empty expectedResponse = Empty.newBuilder().build();
1183     Operation resultOperation =
1184         Operation.newBuilder()
1185             .setName("batchUpdateEntitiesTest")
1186             .setDone(true)
1187             .setResponse(Any.pack(expectedResponse))
1188             .build();
1189     mockEntityTypes.addResponse(resultOperation);
1190 
1191     String parent = "parent-995424086";
1192     List<EntityType.Entity> entities = new ArrayList<>();
1193 
1194     client.batchUpdateEntitiesAsync(parent, entities).get();
1195 
1196     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1197     Assert.assertEquals(1, actualRequests.size());
1198     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1199 
1200     Assert.assertEquals(parent, actualRequest.getParent());
1201     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1202     Assert.assertTrue(
1203         channelProvider.isHeaderSent(
1204             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1205             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1206   }
1207 
1208   @Test
batchUpdateEntitiesExceptionTest2()1209   public void batchUpdateEntitiesExceptionTest2() throws Exception {
1210     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1211     mockEntityTypes.addException(exception);
1212 
1213     try {
1214       String parent = "parent-995424086";
1215       List<EntityType.Entity> entities = new ArrayList<>();
1216       client.batchUpdateEntitiesAsync(parent, entities).get();
1217       Assert.fail("No exception raised");
1218     } catch (ExecutionException e) {
1219       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1220       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1221       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1222     }
1223   }
1224 
1225   @Test
batchUpdateEntitiesTest3()1226   public void batchUpdateEntitiesTest3() throws Exception {
1227     Empty expectedResponse = Empty.newBuilder().build();
1228     Operation resultOperation =
1229         Operation.newBuilder()
1230             .setName("batchUpdateEntitiesTest")
1231             .setDone(true)
1232             .setResponse(Any.pack(expectedResponse))
1233             .build();
1234     mockEntityTypes.addResponse(resultOperation);
1235 
1236     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1237     List<EntityType.Entity> entities = new ArrayList<>();
1238     String languageCode = "languageCode-2092349083";
1239 
1240     client.batchUpdateEntitiesAsync(parent, entities, languageCode).get();
1241 
1242     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1243     Assert.assertEquals(1, actualRequests.size());
1244     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1245 
1246     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1247     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1248     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1249     Assert.assertTrue(
1250         channelProvider.isHeaderSent(
1251             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1252             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1253   }
1254 
1255   @Test
batchUpdateEntitiesExceptionTest3()1256   public void batchUpdateEntitiesExceptionTest3() throws Exception {
1257     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1258     mockEntityTypes.addException(exception);
1259 
1260     try {
1261       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1262       List<EntityType.Entity> entities = new ArrayList<>();
1263       String languageCode = "languageCode-2092349083";
1264       client.batchUpdateEntitiesAsync(parent, entities, languageCode).get();
1265       Assert.fail("No exception raised");
1266     } catch (ExecutionException e) {
1267       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1268       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1269       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1270     }
1271   }
1272 
1273   @Test
batchUpdateEntitiesTest4()1274   public void batchUpdateEntitiesTest4() throws Exception {
1275     Empty expectedResponse = Empty.newBuilder().build();
1276     Operation resultOperation =
1277         Operation.newBuilder()
1278             .setName("batchUpdateEntitiesTest")
1279             .setDone(true)
1280             .setResponse(Any.pack(expectedResponse))
1281             .build();
1282     mockEntityTypes.addResponse(resultOperation);
1283 
1284     String parent = "parent-995424086";
1285     List<EntityType.Entity> entities = new ArrayList<>();
1286     String languageCode = "languageCode-2092349083";
1287 
1288     client.batchUpdateEntitiesAsync(parent, entities, languageCode).get();
1289 
1290     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1291     Assert.assertEquals(1, actualRequests.size());
1292     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1293 
1294     Assert.assertEquals(parent, actualRequest.getParent());
1295     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1296     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1297     Assert.assertTrue(
1298         channelProvider.isHeaderSent(
1299             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1300             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1301   }
1302 
1303   @Test
batchUpdateEntitiesExceptionTest4()1304   public void batchUpdateEntitiesExceptionTest4() throws Exception {
1305     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1306     mockEntityTypes.addException(exception);
1307 
1308     try {
1309       String parent = "parent-995424086";
1310       List<EntityType.Entity> entities = new ArrayList<>();
1311       String languageCode = "languageCode-2092349083";
1312       client.batchUpdateEntitiesAsync(parent, entities, languageCode).get();
1313       Assert.fail("No exception raised");
1314     } catch (ExecutionException e) {
1315       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1316       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1317       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1318     }
1319   }
1320 
1321   @Test
batchDeleteEntitiesTest()1322   public void batchDeleteEntitiesTest() throws Exception {
1323     Empty expectedResponse = Empty.newBuilder().build();
1324     Operation resultOperation =
1325         Operation.newBuilder()
1326             .setName("batchDeleteEntitiesTest")
1327             .setDone(true)
1328             .setResponse(Any.pack(expectedResponse))
1329             .build();
1330     mockEntityTypes.addResponse(resultOperation);
1331 
1332     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1333     List<String> entityValues = new ArrayList<>();
1334 
1335     client.batchDeleteEntitiesAsync(parent, entityValues).get();
1336 
1337     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1338     Assert.assertEquals(1, actualRequests.size());
1339     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1340 
1341     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1342     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1343     Assert.assertTrue(
1344         channelProvider.isHeaderSent(
1345             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1346             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1347   }
1348 
1349   @Test
batchDeleteEntitiesExceptionTest()1350   public void batchDeleteEntitiesExceptionTest() throws Exception {
1351     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1352     mockEntityTypes.addException(exception);
1353 
1354     try {
1355       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1356       List<String> entityValues = new ArrayList<>();
1357       client.batchDeleteEntitiesAsync(parent, entityValues).get();
1358       Assert.fail("No exception raised");
1359     } catch (ExecutionException e) {
1360       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1361       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1362       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1363     }
1364   }
1365 
1366   @Test
batchDeleteEntitiesTest2()1367   public void batchDeleteEntitiesTest2() throws Exception {
1368     Empty expectedResponse = Empty.newBuilder().build();
1369     Operation resultOperation =
1370         Operation.newBuilder()
1371             .setName("batchDeleteEntitiesTest")
1372             .setDone(true)
1373             .setResponse(Any.pack(expectedResponse))
1374             .build();
1375     mockEntityTypes.addResponse(resultOperation);
1376 
1377     String parent = "parent-995424086";
1378     List<String> entityValues = new ArrayList<>();
1379 
1380     client.batchDeleteEntitiesAsync(parent, entityValues).get();
1381 
1382     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1383     Assert.assertEquals(1, actualRequests.size());
1384     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1385 
1386     Assert.assertEquals(parent, actualRequest.getParent());
1387     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1388     Assert.assertTrue(
1389         channelProvider.isHeaderSent(
1390             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1391             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1392   }
1393 
1394   @Test
batchDeleteEntitiesExceptionTest2()1395   public void batchDeleteEntitiesExceptionTest2() throws Exception {
1396     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1397     mockEntityTypes.addException(exception);
1398 
1399     try {
1400       String parent = "parent-995424086";
1401       List<String> entityValues = new ArrayList<>();
1402       client.batchDeleteEntitiesAsync(parent, entityValues).get();
1403       Assert.fail("No exception raised");
1404     } catch (ExecutionException e) {
1405       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1406       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1407       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1408     }
1409   }
1410 
1411   @Test
batchDeleteEntitiesTest3()1412   public void batchDeleteEntitiesTest3() throws Exception {
1413     Empty expectedResponse = Empty.newBuilder().build();
1414     Operation resultOperation =
1415         Operation.newBuilder()
1416             .setName("batchDeleteEntitiesTest")
1417             .setDone(true)
1418             .setResponse(Any.pack(expectedResponse))
1419             .build();
1420     mockEntityTypes.addResponse(resultOperation);
1421 
1422     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1423     List<String> entityValues = new ArrayList<>();
1424     String languageCode = "languageCode-2092349083";
1425 
1426     client.batchDeleteEntitiesAsync(parent, entityValues, languageCode).get();
1427 
1428     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1429     Assert.assertEquals(1, actualRequests.size());
1430     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1431 
1432     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1433     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1434     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1435     Assert.assertTrue(
1436         channelProvider.isHeaderSent(
1437             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1438             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1439   }
1440 
1441   @Test
batchDeleteEntitiesExceptionTest3()1442   public void batchDeleteEntitiesExceptionTest3() throws Exception {
1443     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1444     mockEntityTypes.addException(exception);
1445 
1446     try {
1447       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1448       List<String> entityValues = new ArrayList<>();
1449       String languageCode = "languageCode-2092349083";
1450       client.batchDeleteEntitiesAsync(parent, entityValues, languageCode).get();
1451       Assert.fail("No exception raised");
1452     } catch (ExecutionException e) {
1453       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1454       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1455       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1456     }
1457   }
1458 
1459   @Test
batchDeleteEntitiesTest4()1460   public void batchDeleteEntitiesTest4() throws Exception {
1461     Empty expectedResponse = Empty.newBuilder().build();
1462     Operation resultOperation =
1463         Operation.newBuilder()
1464             .setName("batchDeleteEntitiesTest")
1465             .setDone(true)
1466             .setResponse(Any.pack(expectedResponse))
1467             .build();
1468     mockEntityTypes.addResponse(resultOperation);
1469 
1470     String parent = "parent-995424086";
1471     List<String> entityValues = new ArrayList<>();
1472     String languageCode = "languageCode-2092349083";
1473 
1474     client.batchDeleteEntitiesAsync(parent, entityValues, languageCode).get();
1475 
1476     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1477     Assert.assertEquals(1, actualRequests.size());
1478     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1479 
1480     Assert.assertEquals(parent, actualRequest.getParent());
1481     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1482     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1483     Assert.assertTrue(
1484         channelProvider.isHeaderSent(
1485             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1486             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1487   }
1488 
1489   @Test
batchDeleteEntitiesExceptionTest4()1490   public void batchDeleteEntitiesExceptionTest4() throws Exception {
1491     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1492     mockEntityTypes.addException(exception);
1493 
1494     try {
1495       String parent = "parent-995424086";
1496       List<String> entityValues = new ArrayList<>();
1497       String languageCode = "languageCode-2092349083";
1498       client.batchDeleteEntitiesAsync(parent, entityValues, languageCode).get();
1499       Assert.fail("No exception raised");
1500     } catch (ExecutionException e) {
1501       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1502       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1503       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1504     }
1505   }
1506 
1507   @Test
listLocationsTest()1508   public void listLocationsTest() throws Exception {
1509     Location responsesElement = Location.newBuilder().build();
1510     ListLocationsResponse expectedResponse =
1511         ListLocationsResponse.newBuilder()
1512             .setNextPageToken("")
1513             .addAllLocations(Arrays.asList(responsesElement))
1514             .build();
1515     mockLocations.addResponse(expectedResponse);
1516 
1517     ListLocationsRequest request =
1518         ListLocationsRequest.newBuilder()
1519             .setName("name3373707")
1520             .setFilter("filter-1274492040")
1521             .setPageSize(883849137)
1522             .setPageToken("pageToken873572522")
1523             .build();
1524 
1525     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1526 
1527     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1528 
1529     Assert.assertEquals(1, resources.size());
1530     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1531 
1532     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1533     Assert.assertEquals(1, actualRequests.size());
1534     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1535 
1536     Assert.assertEquals(request.getName(), actualRequest.getName());
1537     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1538     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1539     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1540     Assert.assertTrue(
1541         channelProvider.isHeaderSent(
1542             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1543             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1544   }
1545 
1546   @Test
listLocationsExceptionTest()1547   public void listLocationsExceptionTest() throws Exception {
1548     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1549     mockLocations.addException(exception);
1550 
1551     try {
1552       ListLocationsRequest request =
1553           ListLocationsRequest.newBuilder()
1554               .setName("name3373707")
1555               .setFilter("filter-1274492040")
1556               .setPageSize(883849137)
1557               .setPageToken("pageToken873572522")
1558               .build();
1559       client.listLocations(request);
1560       Assert.fail("No exception raised");
1561     } catch (InvalidArgumentException e) {
1562       // Expected exception.
1563     }
1564   }
1565 
1566   @Test
getLocationTest()1567   public void getLocationTest() throws Exception {
1568     Location expectedResponse =
1569         Location.newBuilder()
1570             .setName("name3373707")
1571             .setLocationId("locationId1541836720")
1572             .setDisplayName("displayName1714148973")
1573             .putAllLabels(new HashMap<String, String>())
1574             .setMetadata(Any.newBuilder().build())
1575             .build();
1576     mockLocations.addResponse(expectedResponse);
1577 
1578     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1579 
1580     Location actualResponse = client.getLocation(request);
1581     Assert.assertEquals(expectedResponse, actualResponse);
1582 
1583     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1584     Assert.assertEquals(1, actualRequests.size());
1585     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1586 
1587     Assert.assertEquals(request.getName(), actualRequest.getName());
1588     Assert.assertTrue(
1589         channelProvider.isHeaderSent(
1590             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1591             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1592   }
1593 
1594   @Test
getLocationExceptionTest()1595   public void getLocationExceptionTest() throws Exception {
1596     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1597     mockLocations.addException(exception);
1598 
1599     try {
1600       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1601       client.getLocation(request);
1602       Assert.fail("No exception raised");
1603     } catch (InvalidArgumentException e) {
1604       // Expected exception.
1605     }
1606   }
1607 }
1608