• 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.v2beta1;
18 
19 import static com.google.cloud.dialogflow.v2beta1.EntityTypesClient.ListEntityTypesPagedResponse;
20 import static com.google.cloud.dialogflow.v2beta1.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.ofProjectAgentName("[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.ofProjectAgentName("[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.ofProjectAgentName("[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.ofProjectAgentName("[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.ofProjectAgentName("[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.ofProjectAgentName("[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.ofProjectAgentName("[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.ofProjectAgentName("[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
updateEntityTypeTest3()727   public void updateEntityTypeTest3() throws Exception {
728     EntityType expectedResponse =
729         EntityType.newBuilder()
730             .setName(
731                 EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]").toString())
732             .setDisplayName("displayName1714148973")
733             .addAllEntities(new ArrayList<EntityType.Entity>())
734             .setEnableFuzzyExtraction(true)
735             .build();
736     mockEntityTypes.addResponse(expectedResponse);
737 
738     EntityType entityType = EntityType.newBuilder().build();
739     String languageCode = "languageCode-2092349083";
740     FieldMask updateMask = FieldMask.newBuilder().build();
741 
742     EntityType actualResponse = client.updateEntityType(entityType, languageCode, updateMask);
743     Assert.assertEquals(expectedResponse, actualResponse);
744 
745     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
746     Assert.assertEquals(1, actualRequests.size());
747     UpdateEntityTypeRequest actualRequest = ((UpdateEntityTypeRequest) actualRequests.get(0));
748 
749     Assert.assertEquals(entityType, actualRequest.getEntityType());
750     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
751     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
752     Assert.assertTrue(
753         channelProvider.isHeaderSent(
754             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
755             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
756   }
757 
758   @Test
updateEntityTypeExceptionTest3()759   public void updateEntityTypeExceptionTest3() throws Exception {
760     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
761     mockEntityTypes.addException(exception);
762 
763     try {
764       EntityType entityType = EntityType.newBuilder().build();
765       String languageCode = "languageCode-2092349083";
766       FieldMask updateMask = FieldMask.newBuilder().build();
767       client.updateEntityType(entityType, languageCode, updateMask);
768       Assert.fail("No exception raised");
769     } catch (InvalidArgumentException e) {
770       // Expected exception.
771     }
772   }
773 
774   @Test
deleteEntityTypeTest()775   public void deleteEntityTypeTest() throws Exception {
776     Empty expectedResponse = Empty.newBuilder().build();
777     mockEntityTypes.addResponse(expectedResponse);
778 
779     EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
780 
781     client.deleteEntityType(name);
782 
783     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
784     Assert.assertEquals(1, actualRequests.size());
785     DeleteEntityTypeRequest actualRequest = ((DeleteEntityTypeRequest) actualRequests.get(0));
786 
787     Assert.assertEquals(name.toString(), actualRequest.getName());
788     Assert.assertTrue(
789         channelProvider.isHeaderSent(
790             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
791             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
792   }
793 
794   @Test
deleteEntityTypeExceptionTest()795   public void deleteEntityTypeExceptionTest() throws Exception {
796     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
797     mockEntityTypes.addException(exception);
798 
799     try {
800       EntityTypeName name = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
801       client.deleteEntityType(name);
802       Assert.fail("No exception raised");
803     } catch (InvalidArgumentException e) {
804       // Expected exception.
805     }
806   }
807 
808   @Test
deleteEntityTypeTest2()809   public void deleteEntityTypeTest2() throws Exception {
810     Empty expectedResponse = Empty.newBuilder().build();
811     mockEntityTypes.addResponse(expectedResponse);
812 
813     String name = "name3373707";
814 
815     client.deleteEntityType(name);
816 
817     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
818     Assert.assertEquals(1, actualRequests.size());
819     DeleteEntityTypeRequest actualRequest = ((DeleteEntityTypeRequest) actualRequests.get(0));
820 
821     Assert.assertEquals(name, actualRequest.getName());
822     Assert.assertTrue(
823         channelProvider.isHeaderSent(
824             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
825             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
826   }
827 
828   @Test
deleteEntityTypeExceptionTest2()829   public void deleteEntityTypeExceptionTest2() throws Exception {
830     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
831     mockEntityTypes.addException(exception);
832 
833     try {
834       String name = "name3373707";
835       client.deleteEntityType(name);
836       Assert.fail("No exception raised");
837     } catch (InvalidArgumentException e) {
838       // Expected exception.
839     }
840   }
841 
842   @Test
batchUpdateEntityTypesTest()843   public void batchUpdateEntityTypesTest() throws Exception {
844     BatchUpdateEntityTypesResponse expectedResponse =
845         BatchUpdateEntityTypesResponse.newBuilder()
846             .addAllEntityTypes(new ArrayList<EntityType>())
847             .build();
848     Operation resultOperation =
849         Operation.newBuilder()
850             .setName("batchUpdateEntityTypesTest")
851             .setDone(true)
852             .setResponse(Any.pack(expectedResponse))
853             .build();
854     mockEntityTypes.addResponse(resultOperation);
855 
856     BatchUpdateEntityTypesRequest request =
857         BatchUpdateEntityTypesRequest.newBuilder()
858             .setParent(AgentName.ofProjectAgentName("[PROJECT]").toString())
859             .setLanguageCode("languageCode-2092349083")
860             .setUpdateMask(FieldMask.newBuilder().build())
861             .build();
862 
863     BatchUpdateEntityTypesResponse actualResponse =
864         client.batchUpdateEntityTypesAsync(request).get();
865     Assert.assertEquals(expectedResponse, actualResponse);
866 
867     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
868     Assert.assertEquals(1, actualRequests.size());
869     BatchUpdateEntityTypesRequest actualRequest =
870         ((BatchUpdateEntityTypesRequest) actualRequests.get(0));
871 
872     Assert.assertEquals(request.getParent(), actualRequest.getParent());
873     Assert.assertEquals(request.getEntityTypeBatchUri(), actualRequest.getEntityTypeBatchUri());
874     Assert.assertEquals(
875         request.getEntityTypeBatchInline(), actualRequest.getEntityTypeBatchInline());
876     Assert.assertEquals(request.getLanguageCode(), actualRequest.getLanguageCode());
877     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
878     Assert.assertTrue(
879         channelProvider.isHeaderSent(
880             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
881             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
882   }
883 
884   @Test
batchUpdateEntityTypesExceptionTest()885   public void batchUpdateEntityTypesExceptionTest() throws Exception {
886     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
887     mockEntityTypes.addException(exception);
888 
889     try {
890       BatchUpdateEntityTypesRequest request =
891           BatchUpdateEntityTypesRequest.newBuilder()
892               .setParent(AgentName.ofProjectAgentName("[PROJECT]").toString())
893               .setLanguageCode("languageCode-2092349083")
894               .setUpdateMask(FieldMask.newBuilder().build())
895               .build();
896       client.batchUpdateEntityTypesAsync(request).get();
897       Assert.fail("No exception raised");
898     } catch (ExecutionException e) {
899       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
900       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
901       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
902     }
903   }
904 
905   @Test
batchDeleteEntityTypesTest()906   public void batchDeleteEntityTypesTest() throws Exception {
907     Empty expectedResponse = Empty.newBuilder().build();
908     Operation resultOperation =
909         Operation.newBuilder()
910             .setName("batchDeleteEntityTypesTest")
911             .setDone(true)
912             .setResponse(Any.pack(expectedResponse))
913             .build();
914     mockEntityTypes.addResponse(resultOperation);
915 
916     AgentName parent = AgentName.ofProjectAgentName("[PROJECT]");
917     List<String> entityTypeNames = new ArrayList<>();
918 
919     client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
920 
921     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
922     Assert.assertEquals(1, actualRequests.size());
923     BatchDeleteEntityTypesRequest actualRequest =
924         ((BatchDeleteEntityTypesRequest) actualRequests.get(0));
925 
926     Assert.assertEquals(parent.toString(), actualRequest.getParent());
927     Assert.assertEquals(entityTypeNames, actualRequest.getEntityTypeNamesList());
928     Assert.assertTrue(
929         channelProvider.isHeaderSent(
930             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
931             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
932   }
933 
934   @Test
batchDeleteEntityTypesExceptionTest()935   public void batchDeleteEntityTypesExceptionTest() throws Exception {
936     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
937     mockEntityTypes.addException(exception);
938 
939     try {
940       AgentName parent = AgentName.ofProjectAgentName("[PROJECT]");
941       List<String> entityTypeNames = new ArrayList<>();
942       client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
943       Assert.fail("No exception raised");
944     } catch (ExecutionException e) {
945       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
946       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
947       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
948     }
949   }
950 
951   @Test
batchDeleteEntityTypesTest2()952   public void batchDeleteEntityTypesTest2() throws Exception {
953     Empty expectedResponse = Empty.newBuilder().build();
954     Operation resultOperation =
955         Operation.newBuilder()
956             .setName("batchDeleteEntityTypesTest")
957             .setDone(true)
958             .setResponse(Any.pack(expectedResponse))
959             .build();
960     mockEntityTypes.addResponse(resultOperation);
961 
962     String parent = "parent-995424086";
963     List<String> entityTypeNames = new ArrayList<>();
964 
965     client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
966 
967     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
968     Assert.assertEquals(1, actualRequests.size());
969     BatchDeleteEntityTypesRequest actualRequest =
970         ((BatchDeleteEntityTypesRequest) actualRequests.get(0));
971 
972     Assert.assertEquals(parent, actualRequest.getParent());
973     Assert.assertEquals(entityTypeNames, actualRequest.getEntityTypeNamesList());
974     Assert.assertTrue(
975         channelProvider.isHeaderSent(
976             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
977             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
978   }
979 
980   @Test
batchDeleteEntityTypesExceptionTest2()981   public void batchDeleteEntityTypesExceptionTest2() throws Exception {
982     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
983     mockEntityTypes.addException(exception);
984 
985     try {
986       String parent = "parent-995424086";
987       List<String> entityTypeNames = new ArrayList<>();
988       client.batchDeleteEntityTypesAsync(parent, entityTypeNames).get();
989       Assert.fail("No exception raised");
990     } catch (ExecutionException e) {
991       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
992       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
993       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
994     }
995   }
996 
997   @Test
batchCreateEntitiesTest()998   public void batchCreateEntitiesTest() throws Exception {
999     Empty expectedResponse = Empty.newBuilder().build();
1000     Operation resultOperation =
1001         Operation.newBuilder()
1002             .setName("batchCreateEntitiesTest")
1003             .setDone(true)
1004             .setResponse(Any.pack(expectedResponse))
1005             .build();
1006     mockEntityTypes.addResponse(resultOperation);
1007 
1008     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1009     List<EntityType.Entity> entities = new ArrayList<>();
1010 
1011     client.batchCreateEntitiesAsync(parent, entities).get();
1012 
1013     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1014     Assert.assertEquals(1, actualRequests.size());
1015     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
1016 
1017     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1018     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1019     Assert.assertTrue(
1020         channelProvider.isHeaderSent(
1021             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1022             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1023   }
1024 
1025   @Test
batchCreateEntitiesExceptionTest()1026   public void batchCreateEntitiesExceptionTest() throws Exception {
1027     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1028     mockEntityTypes.addException(exception);
1029 
1030     try {
1031       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1032       List<EntityType.Entity> entities = new ArrayList<>();
1033       client.batchCreateEntitiesAsync(parent, entities).get();
1034       Assert.fail("No exception raised");
1035     } catch (ExecutionException e) {
1036       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1037       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1038       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1039     }
1040   }
1041 
1042   @Test
batchCreateEntitiesTest2()1043   public void batchCreateEntitiesTest2() throws Exception {
1044     Empty expectedResponse = Empty.newBuilder().build();
1045     Operation resultOperation =
1046         Operation.newBuilder()
1047             .setName("batchCreateEntitiesTest")
1048             .setDone(true)
1049             .setResponse(Any.pack(expectedResponse))
1050             .build();
1051     mockEntityTypes.addResponse(resultOperation);
1052 
1053     String parent = "parent-995424086";
1054     List<EntityType.Entity> entities = new ArrayList<>();
1055 
1056     client.batchCreateEntitiesAsync(parent, entities).get();
1057 
1058     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1059     Assert.assertEquals(1, actualRequests.size());
1060     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
1061 
1062     Assert.assertEquals(parent, actualRequest.getParent());
1063     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1064     Assert.assertTrue(
1065         channelProvider.isHeaderSent(
1066             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1067             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1068   }
1069 
1070   @Test
batchCreateEntitiesExceptionTest2()1071   public void batchCreateEntitiesExceptionTest2() throws Exception {
1072     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1073     mockEntityTypes.addException(exception);
1074 
1075     try {
1076       String parent = "parent-995424086";
1077       List<EntityType.Entity> entities = new ArrayList<>();
1078       client.batchCreateEntitiesAsync(parent, entities).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
batchCreateEntitiesTest3()1088   public void batchCreateEntitiesTest3() 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     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
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.toString(), 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
batchCreateEntitiesExceptionTest3()1118   public void batchCreateEntitiesExceptionTest3() throws Exception {
1119     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1120     mockEntityTypes.addException(exception);
1121 
1122     try {
1123       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
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
batchCreateEntitiesTest4()1136   public void batchCreateEntitiesTest4() throws Exception {
1137     Empty expectedResponse = Empty.newBuilder().build();
1138     Operation resultOperation =
1139         Operation.newBuilder()
1140             .setName("batchCreateEntitiesTest")
1141             .setDone(true)
1142             .setResponse(Any.pack(expectedResponse))
1143             .build();
1144     mockEntityTypes.addResponse(resultOperation);
1145 
1146     String parent = "parent-995424086";
1147     List<EntityType.Entity> entities = new ArrayList<>();
1148     String languageCode = "languageCode-2092349083";
1149 
1150     client.batchCreateEntitiesAsync(parent, entities, languageCode).get();
1151 
1152     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1153     Assert.assertEquals(1, actualRequests.size());
1154     BatchCreateEntitiesRequest actualRequest = ((BatchCreateEntitiesRequest) actualRequests.get(0));
1155 
1156     Assert.assertEquals(parent, actualRequest.getParent());
1157     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1158     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1159     Assert.assertTrue(
1160         channelProvider.isHeaderSent(
1161             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1162             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1163   }
1164 
1165   @Test
batchCreateEntitiesExceptionTest4()1166   public void batchCreateEntitiesExceptionTest4() throws Exception {
1167     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1168     mockEntityTypes.addException(exception);
1169 
1170     try {
1171       String parent = "parent-995424086";
1172       List<EntityType.Entity> entities = new ArrayList<>();
1173       String languageCode = "languageCode-2092349083";
1174       client.batchCreateEntitiesAsync(parent, entities, languageCode).get();
1175       Assert.fail("No exception raised");
1176     } catch (ExecutionException e) {
1177       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1178       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1179       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1180     }
1181   }
1182 
1183   @Test
batchUpdateEntitiesTest()1184   public void batchUpdateEntitiesTest() throws Exception {
1185     Empty expectedResponse = Empty.newBuilder().build();
1186     Operation resultOperation =
1187         Operation.newBuilder()
1188             .setName("batchUpdateEntitiesTest")
1189             .setDone(true)
1190             .setResponse(Any.pack(expectedResponse))
1191             .build();
1192     mockEntityTypes.addResponse(resultOperation);
1193 
1194     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1195     List<EntityType.Entity> entities = new ArrayList<>();
1196 
1197     client.batchUpdateEntitiesAsync(parent, entities).get();
1198 
1199     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1200     Assert.assertEquals(1, actualRequests.size());
1201     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1202 
1203     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1204     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1205     Assert.assertTrue(
1206         channelProvider.isHeaderSent(
1207             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1208             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1209   }
1210 
1211   @Test
batchUpdateEntitiesExceptionTest()1212   public void batchUpdateEntitiesExceptionTest() throws Exception {
1213     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1214     mockEntityTypes.addException(exception);
1215 
1216     try {
1217       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1218       List<EntityType.Entity> entities = new ArrayList<>();
1219       client.batchUpdateEntitiesAsync(parent, entities).get();
1220       Assert.fail("No exception raised");
1221     } catch (ExecutionException e) {
1222       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1223       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1224       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1225     }
1226   }
1227 
1228   @Test
batchUpdateEntitiesTest2()1229   public void batchUpdateEntitiesTest2() throws Exception {
1230     Empty expectedResponse = Empty.newBuilder().build();
1231     Operation resultOperation =
1232         Operation.newBuilder()
1233             .setName("batchUpdateEntitiesTest")
1234             .setDone(true)
1235             .setResponse(Any.pack(expectedResponse))
1236             .build();
1237     mockEntityTypes.addResponse(resultOperation);
1238 
1239     String parent = "parent-995424086";
1240     List<EntityType.Entity> entities = new ArrayList<>();
1241 
1242     client.batchUpdateEntitiesAsync(parent, entities).get();
1243 
1244     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1245     Assert.assertEquals(1, actualRequests.size());
1246     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1247 
1248     Assert.assertEquals(parent, actualRequest.getParent());
1249     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1250     Assert.assertTrue(
1251         channelProvider.isHeaderSent(
1252             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1253             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1254   }
1255 
1256   @Test
batchUpdateEntitiesExceptionTest2()1257   public void batchUpdateEntitiesExceptionTest2() throws Exception {
1258     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1259     mockEntityTypes.addException(exception);
1260 
1261     try {
1262       String parent = "parent-995424086";
1263       List<EntityType.Entity> entities = new ArrayList<>();
1264       client.batchUpdateEntitiesAsync(parent, entities).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
batchUpdateEntitiesTest3()1274   public void batchUpdateEntitiesTest3() 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     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
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.toString(), 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
batchUpdateEntitiesExceptionTest3()1304   public void batchUpdateEntitiesExceptionTest3() throws Exception {
1305     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1306     mockEntityTypes.addException(exception);
1307 
1308     try {
1309       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
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
batchUpdateEntitiesTest4()1322   public void batchUpdateEntitiesTest4() throws Exception {
1323     Empty expectedResponse = Empty.newBuilder().build();
1324     Operation resultOperation =
1325         Operation.newBuilder()
1326             .setName("batchUpdateEntitiesTest")
1327             .setDone(true)
1328             .setResponse(Any.pack(expectedResponse))
1329             .build();
1330     mockEntityTypes.addResponse(resultOperation);
1331 
1332     String parent = "parent-995424086";
1333     List<EntityType.Entity> entities = new ArrayList<>();
1334     String languageCode = "languageCode-2092349083";
1335 
1336     client.batchUpdateEntitiesAsync(parent, entities, languageCode).get();
1337 
1338     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1339     Assert.assertEquals(1, actualRequests.size());
1340     BatchUpdateEntitiesRequest actualRequest = ((BatchUpdateEntitiesRequest) actualRequests.get(0));
1341 
1342     Assert.assertEquals(parent, actualRequest.getParent());
1343     Assert.assertEquals(entities, actualRequest.getEntitiesList());
1344     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1345     Assert.assertTrue(
1346         channelProvider.isHeaderSent(
1347             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1348             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1349   }
1350 
1351   @Test
batchUpdateEntitiesExceptionTest4()1352   public void batchUpdateEntitiesExceptionTest4() throws Exception {
1353     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1354     mockEntityTypes.addException(exception);
1355 
1356     try {
1357       String parent = "parent-995424086";
1358       List<EntityType.Entity> entities = new ArrayList<>();
1359       String languageCode = "languageCode-2092349083";
1360       client.batchUpdateEntitiesAsync(parent, entities, languageCode).get();
1361       Assert.fail("No exception raised");
1362     } catch (ExecutionException e) {
1363       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1364       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1365       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1366     }
1367   }
1368 
1369   @Test
batchDeleteEntitiesTest()1370   public void batchDeleteEntitiesTest() throws Exception {
1371     Empty expectedResponse = Empty.newBuilder().build();
1372     Operation resultOperation =
1373         Operation.newBuilder()
1374             .setName("batchDeleteEntitiesTest")
1375             .setDone(true)
1376             .setResponse(Any.pack(expectedResponse))
1377             .build();
1378     mockEntityTypes.addResponse(resultOperation);
1379 
1380     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1381     List<String> entityValues = new ArrayList<>();
1382 
1383     client.batchDeleteEntitiesAsync(parent, entityValues).get();
1384 
1385     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1386     Assert.assertEquals(1, actualRequests.size());
1387     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1388 
1389     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1390     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1391     Assert.assertTrue(
1392         channelProvider.isHeaderSent(
1393             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1394             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1395   }
1396 
1397   @Test
batchDeleteEntitiesExceptionTest()1398   public void batchDeleteEntitiesExceptionTest() throws Exception {
1399     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1400     mockEntityTypes.addException(exception);
1401 
1402     try {
1403       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
1404       List<String> entityValues = new ArrayList<>();
1405       client.batchDeleteEntitiesAsync(parent, entityValues).get();
1406       Assert.fail("No exception raised");
1407     } catch (ExecutionException e) {
1408       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1409       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1410       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1411     }
1412   }
1413 
1414   @Test
batchDeleteEntitiesTest2()1415   public void batchDeleteEntitiesTest2() throws Exception {
1416     Empty expectedResponse = Empty.newBuilder().build();
1417     Operation resultOperation =
1418         Operation.newBuilder()
1419             .setName("batchDeleteEntitiesTest")
1420             .setDone(true)
1421             .setResponse(Any.pack(expectedResponse))
1422             .build();
1423     mockEntityTypes.addResponse(resultOperation);
1424 
1425     String parent = "parent-995424086";
1426     List<String> entityValues = new ArrayList<>();
1427 
1428     client.batchDeleteEntitiesAsync(parent, entityValues).get();
1429 
1430     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1431     Assert.assertEquals(1, actualRequests.size());
1432     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1433 
1434     Assert.assertEquals(parent, actualRequest.getParent());
1435     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1436     Assert.assertTrue(
1437         channelProvider.isHeaderSent(
1438             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1439             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1440   }
1441 
1442   @Test
batchDeleteEntitiesExceptionTest2()1443   public void batchDeleteEntitiesExceptionTest2() throws Exception {
1444     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1445     mockEntityTypes.addException(exception);
1446 
1447     try {
1448       String parent = "parent-995424086";
1449       List<String> entityValues = new ArrayList<>();
1450       client.batchDeleteEntitiesAsync(parent, entityValues).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
batchDeleteEntitiesTest3()1460   public void batchDeleteEntitiesTest3() 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     EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
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.toString(), 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
batchDeleteEntitiesExceptionTest3()1490   public void batchDeleteEntitiesExceptionTest3() throws Exception {
1491     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1492     mockEntityTypes.addException(exception);
1493 
1494     try {
1495       EntityTypeName parent = EntityTypeName.ofProjectEntityTypeName("[PROJECT]", "[ENTITY_TYPE]");
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
batchDeleteEntitiesTest4()1508   public void batchDeleteEntitiesTest4() throws Exception {
1509     Empty expectedResponse = Empty.newBuilder().build();
1510     Operation resultOperation =
1511         Operation.newBuilder()
1512             .setName("batchDeleteEntitiesTest")
1513             .setDone(true)
1514             .setResponse(Any.pack(expectedResponse))
1515             .build();
1516     mockEntityTypes.addResponse(resultOperation);
1517 
1518     String parent = "parent-995424086";
1519     List<String> entityValues = new ArrayList<>();
1520     String languageCode = "languageCode-2092349083";
1521 
1522     client.batchDeleteEntitiesAsync(parent, entityValues, languageCode).get();
1523 
1524     List<AbstractMessage> actualRequests = mockEntityTypes.getRequests();
1525     Assert.assertEquals(1, actualRequests.size());
1526     BatchDeleteEntitiesRequest actualRequest = ((BatchDeleteEntitiesRequest) actualRequests.get(0));
1527 
1528     Assert.assertEquals(parent, actualRequest.getParent());
1529     Assert.assertEquals(entityValues, actualRequest.getEntityValuesList());
1530     Assert.assertEquals(languageCode, actualRequest.getLanguageCode());
1531     Assert.assertTrue(
1532         channelProvider.isHeaderSent(
1533             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1534             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1535   }
1536 
1537   @Test
batchDeleteEntitiesExceptionTest4()1538   public void batchDeleteEntitiesExceptionTest4() throws Exception {
1539     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1540     mockEntityTypes.addException(exception);
1541 
1542     try {
1543       String parent = "parent-995424086";
1544       List<String> entityValues = new ArrayList<>();
1545       String languageCode = "languageCode-2092349083";
1546       client.batchDeleteEntitiesAsync(parent, entityValues, languageCode).get();
1547       Assert.fail("No exception raised");
1548     } catch (ExecutionException e) {
1549       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1550       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1551       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1552     }
1553   }
1554 
1555   @Test
listLocationsTest()1556   public void listLocationsTest() throws Exception {
1557     Location responsesElement = Location.newBuilder().build();
1558     ListLocationsResponse expectedResponse =
1559         ListLocationsResponse.newBuilder()
1560             .setNextPageToken("")
1561             .addAllLocations(Arrays.asList(responsesElement))
1562             .build();
1563     mockLocations.addResponse(expectedResponse);
1564 
1565     ListLocationsRequest request =
1566         ListLocationsRequest.newBuilder()
1567             .setName("name3373707")
1568             .setFilter("filter-1274492040")
1569             .setPageSize(883849137)
1570             .setPageToken("pageToken873572522")
1571             .build();
1572 
1573     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1574 
1575     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1576 
1577     Assert.assertEquals(1, resources.size());
1578     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1579 
1580     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1581     Assert.assertEquals(1, actualRequests.size());
1582     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1583 
1584     Assert.assertEquals(request.getName(), actualRequest.getName());
1585     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1586     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1587     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1588     Assert.assertTrue(
1589         channelProvider.isHeaderSent(
1590             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1591             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1592   }
1593 
1594   @Test
listLocationsExceptionTest()1595   public void listLocationsExceptionTest() throws Exception {
1596     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1597     mockLocations.addException(exception);
1598 
1599     try {
1600       ListLocationsRequest request =
1601           ListLocationsRequest.newBuilder()
1602               .setName("name3373707")
1603               .setFilter("filter-1274492040")
1604               .setPageSize(883849137)
1605               .setPageToken("pageToken873572522")
1606               .build();
1607       client.listLocations(request);
1608       Assert.fail("No exception raised");
1609     } catch (InvalidArgumentException e) {
1610       // Expected exception.
1611     }
1612   }
1613 
1614   @Test
getLocationTest()1615   public void getLocationTest() throws Exception {
1616     Location expectedResponse =
1617         Location.newBuilder()
1618             .setName("name3373707")
1619             .setLocationId("locationId1541836720")
1620             .setDisplayName("displayName1714148973")
1621             .putAllLabels(new HashMap<String, String>())
1622             .setMetadata(Any.newBuilder().build())
1623             .build();
1624     mockLocations.addResponse(expectedResponse);
1625 
1626     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1627 
1628     Location actualResponse = client.getLocation(request);
1629     Assert.assertEquals(expectedResponse, actualResponse);
1630 
1631     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1632     Assert.assertEquals(1, actualRequests.size());
1633     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1634 
1635     Assert.assertEquals(request.getName(), actualRequest.getName());
1636     Assert.assertTrue(
1637         channelProvider.isHeaderSent(
1638             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1639             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1640   }
1641 
1642   @Test
getLocationExceptionTest()1643   public void getLocationExceptionTest() throws Exception {
1644     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1645     mockLocations.addException(exception);
1646 
1647     try {
1648       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1649       client.getLocation(request);
1650       Assert.fail("No exception raised");
1651     } catch (InvalidArgumentException e) {
1652       // Expected exception.
1653     }
1654   }
1655 }
1656