• 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.datacatalog.v1;
18 
19 import static com.google.cloud.datacatalog.v1.DataCatalogClient.ListEntriesPagedResponse;
20 import static com.google.cloud.datacatalog.v1.DataCatalogClient.ListEntryGroupsPagedResponse;
21 import static com.google.cloud.datacatalog.v1.DataCatalogClient.ListTagsPagedResponse;
22 import static com.google.cloud.datacatalog.v1.DataCatalogClient.SearchCatalogPagedResponse;
23 
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.grpc.GaxGrpcProperties;
26 import com.google.api.gax.grpc.testing.LocalChannelProvider;
27 import com.google.api.gax.grpc.testing.MockGrpcService;
28 import com.google.api.gax.grpc.testing.MockServiceHelper;
29 import com.google.api.gax.rpc.ApiClientHeaderProvider;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.api.resourcenames.ResourceName;
33 import com.google.common.collect.Lists;
34 import com.google.iam.v1.AuditConfig;
35 import com.google.iam.v1.Binding;
36 import com.google.iam.v1.GetIamPolicyRequest;
37 import com.google.iam.v1.Policy;
38 import com.google.iam.v1.SetIamPolicyRequest;
39 import com.google.iam.v1.TestIamPermissionsRequest;
40 import com.google.iam.v1.TestIamPermissionsResponse;
41 import com.google.longrunning.Operation;
42 import com.google.protobuf.AbstractMessage;
43 import com.google.protobuf.Any;
44 import com.google.protobuf.ByteString;
45 import com.google.protobuf.Empty;
46 import com.google.protobuf.FieldMask;
47 import io.grpc.StatusRuntimeException;
48 import java.io.IOException;
49 import java.util.ArrayList;
50 import java.util.Arrays;
51 import java.util.HashMap;
52 import java.util.List;
53 import java.util.UUID;
54 import java.util.concurrent.ExecutionException;
55 import javax.annotation.Generated;
56 import org.junit.After;
57 import org.junit.AfterClass;
58 import org.junit.Assert;
59 import org.junit.Before;
60 import org.junit.BeforeClass;
61 import org.junit.Test;
62 
63 @Generated("by gapic-generator-java")
64 public class DataCatalogClientTest {
65   private static MockDataCatalog mockDataCatalog;
66   private static MockIAMPolicy mockIAMPolicy;
67   private static MockServiceHelper mockServiceHelper;
68   private LocalChannelProvider channelProvider;
69   private DataCatalogClient client;
70 
71   @BeforeClass
startStaticServer()72   public static void startStaticServer() {
73     mockDataCatalog = new MockDataCatalog();
74     mockIAMPolicy = new MockIAMPolicy();
75     mockServiceHelper =
76         new MockServiceHelper(
77             UUID.randomUUID().toString(),
78             Arrays.<MockGrpcService>asList(mockDataCatalog, mockIAMPolicy));
79     mockServiceHelper.start();
80   }
81 
82   @AfterClass
stopServer()83   public static void stopServer() {
84     mockServiceHelper.stop();
85   }
86 
87   @Before
setUp()88   public void setUp() throws IOException {
89     mockServiceHelper.reset();
90     channelProvider = mockServiceHelper.createChannelProvider();
91     DataCatalogSettings settings =
92         DataCatalogSettings.newBuilder()
93             .setTransportChannelProvider(channelProvider)
94             .setCredentialsProvider(NoCredentialsProvider.create())
95             .build();
96     client = DataCatalogClient.create(settings);
97   }
98 
99   @After
tearDown()100   public void tearDown() throws Exception {
101     client.close();
102   }
103 
104   @Test
searchCatalogTest()105   public void searchCatalogTest() throws Exception {
106     SearchCatalogResult responsesElement = SearchCatalogResult.newBuilder().build();
107     SearchCatalogResponse expectedResponse =
108         SearchCatalogResponse.newBuilder()
109             .setNextPageToken("")
110             .addAllResults(Arrays.asList(responsesElement))
111             .build();
112     mockDataCatalog.addResponse(expectedResponse);
113 
114     SearchCatalogRequest.Scope scope = SearchCatalogRequest.Scope.newBuilder().build();
115     String query = "query107944136";
116 
117     SearchCatalogPagedResponse pagedListResponse = client.searchCatalog(scope, query);
118 
119     List<SearchCatalogResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());
120 
121     Assert.assertEquals(1, resources.size());
122     Assert.assertEquals(expectedResponse.getResultsList().get(0), resources.get(0));
123 
124     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
125     Assert.assertEquals(1, actualRequests.size());
126     SearchCatalogRequest actualRequest = ((SearchCatalogRequest) actualRequests.get(0));
127 
128     Assert.assertEquals(scope, actualRequest.getScope());
129     Assert.assertEquals(query, actualRequest.getQuery());
130     Assert.assertTrue(
131         channelProvider.isHeaderSent(
132             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
133             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
134   }
135 
136   @Test
searchCatalogExceptionTest()137   public void searchCatalogExceptionTest() throws Exception {
138     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
139     mockDataCatalog.addException(exception);
140 
141     try {
142       SearchCatalogRequest.Scope scope = SearchCatalogRequest.Scope.newBuilder().build();
143       String query = "query107944136";
144       client.searchCatalog(scope, query);
145       Assert.fail("No exception raised");
146     } catch (InvalidArgumentException e) {
147       // Expected exception.
148     }
149   }
150 
151   @Test
createEntryGroupTest()152   public void createEntryGroupTest() throws Exception {
153     EntryGroup expectedResponse =
154         EntryGroup.newBuilder()
155             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
156             .setDisplayName("displayName1714148973")
157             .setDescription("description-1724546052")
158             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
159             .build();
160     mockDataCatalog.addResponse(expectedResponse);
161 
162     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
163     String entryGroupId = "entryGroupId1228924712";
164     EntryGroup entryGroup = EntryGroup.newBuilder().build();
165 
166     EntryGroup actualResponse = client.createEntryGroup(parent, entryGroupId, entryGroup);
167     Assert.assertEquals(expectedResponse, actualResponse);
168 
169     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
170     Assert.assertEquals(1, actualRequests.size());
171     CreateEntryGroupRequest actualRequest = ((CreateEntryGroupRequest) actualRequests.get(0));
172 
173     Assert.assertEquals(parent.toString(), actualRequest.getParent());
174     Assert.assertEquals(entryGroupId, actualRequest.getEntryGroupId());
175     Assert.assertEquals(entryGroup, actualRequest.getEntryGroup());
176     Assert.assertTrue(
177         channelProvider.isHeaderSent(
178             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
179             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
180   }
181 
182   @Test
createEntryGroupExceptionTest()183   public void createEntryGroupExceptionTest() throws Exception {
184     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
185     mockDataCatalog.addException(exception);
186 
187     try {
188       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
189       String entryGroupId = "entryGroupId1228924712";
190       EntryGroup entryGroup = EntryGroup.newBuilder().build();
191       client.createEntryGroup(parent, entryGroupId, entryGroup);
192       Assert.fail("No exception raised");
193     } catch (InvalidArgumentException e) {
194       // Expected exception.
195     }
196   }
197 
198   @Test
createEntryGroupTest2()199   public void createEntryGroupTest2() throws Exception {
200     EntryGroup expectedResponse =
201         EntryGroup.newBuilder()
202             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
203             .setDisplayName("displayName1714148973")
204             .setDescription("description-1724546052")
205             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
206             .build();
207     mockDataCatalog.addResponse(expectedResponse);
208 
209     String parent = "parent-995424086";
210     String entryGroupId = "entryGroupId1228924712";
211     EntryGroup entryGroup = EntryGroup.newBuilder().build();
212 
213     EntryGroup actualResponse = client.createEntryGroup(parent, entryGroupId, entryGroup);
214     Assert.assertEquals(expectedResponse, actualResponse);
215 
216     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
217     Assert.assertEquals(1, actualRequests.size());
218     CreateEntryGroupRequest actualRequest = ((CreateEntryGroupRequest) actualRequests.get(0));
219 
220     Assert.assertEquals(parent, actualRequest.getParent());
221     Assert.assertEquals(entryGroupId, actualRequest.getEntryGroupId());
222     Assert.assertEquals(entryGroup, actualRequest.getEntryGroup());
223     Assert.assertTrue(
224         channelProvider.isHeaderSent(
225             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
226             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
227   }
228 
229   @Test
createEntryGroupExceptionTest2()230   public void createEntryGroupExceptionTest2() throws Exception {
231     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
232     mockDataCatalog.addException(exception);
233 
234     try {
235       String parent = "parent-995424086";
236       String entryGroupId = "entryGroupId1228924712";
237       EntryGroup entryGroup = EntryGroup.newBuilder().build();
238       client.createEntryGroup(parent, entryGroupId, entryGroup);
239       Assert.fail("No exception raised");
240     } catch (InvalidArgumentException e) {
241       // Expected exception.
242     }
243   }
244 
245   @Test
getEntryGroupTest()246   public void getEntryGroupTest() throws Exception {
247     EntryGroup expectedResponse =
248         EntryGroup.newBuilder()
249             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
250             .setDisplayName("displayName1714148973")
251             .setDescription("description-1724546052")
252             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
253             .build();
254     mockDataCatalog.addResponse(expectedResponse);
255 
256     EntryGroupName name = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
257 
258     EntryGroup actualResponse = client.getEntryGroup(name);
259     Assert.assertEquals(expectedResponse, actualResponse);
260 
261     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
262     Assert.assertEquals(1, actualRequests.size());
263     GetEntryGroupRequest actualRequest = ((GetEntryGroupRequest) actualRequests.get(0));
264 
265     Assert.assertEquals(name.toString(), actualRequest.getName());
266     Assert.assertTrue(
267         channelProvider.isHeaderSent(
268             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
269             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
270   }
271 
272   @Test
getEntryGroupExceptionTest()273   public void getEntryGroupExceptionTest() throws Exception {
274     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
275     mockDataCatalog.addException(exception);
276 
277     try {
278       EntryGroupName name = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
279       client.getEntryGroup(name);
280       Assert.fail("No exception raised");
281     } catch (InvalidArgumentException e) {
282       // Expected exception.
283     }
284   }
285 
286   @Test
getEntryGroupTest2()287   public void getEntryGroupTest2() throws Exception {
288     EntryGroup expectedResponse =
289         EntryGroup.newBuilder()
290             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
291             .setDisplayName("displayName1714148973")
292             .setDescription("description-1724546052")
293             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
294             .build();
295     mockDataCatalog.addResponse(expectedResponse);
296 
297     String name = "name3373707";
298 
299     EntryGroup actualResponse = client.getEntryGroup(name);
300     Assert.assertEquals(expectedResponse, actualResponse);
301 
302     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
303     Assert.assertEquals(1, actualRequests.size());
304     GetEntryGroupRequest actualRequest = ((GetEntryGroupRequest) actualRequests.get(0));
305 
306     Assert.assertEquals(name, actualRequest.getName());
307     Assert.assertTrue(
308         channelProvider.isHeaderSent(
309             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
310             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
311   }
312 
313   @Test
getEntryGroupExceptionTest2()314   public void getEntryGroupExceptionTest2() throws Exception {
315     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
316     mockDataCatalog.addException(exception);
317 
318     try {
319       String name = "name3373707";
320       client.getEntryGroup(name);
321       Assert.fail("No exception raised");
322     } catch (InvalidArgumentException e) {
323       // Expected exception.
324     }
325   }
326 
327   @Test
getEntryGroupTest3()328   public void getEntryGroupTest3() throws Exception {
329     EntryGroup expectedResponse =
330         EntryGroup.newBuilder()
331             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
332             .setDisplayName("displayName1714148973")
333             .setDescription("description-1724546052")
334             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
335             .build();
336     mockDataCatalog.addResponse(expectedResponse);
337 
338     EntryGroupName name = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
339     FieldMask readMask = FieldMask.newBuilder().build();
340 
341     EntryGroup actualResponse = client.getEntryGroup(name, readMask);
342     Assert.assertEquals(expectedResponse, actualResponse);
343 
344     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
345     Assert.assertEquals(1, actualRequests.size());
346     GetEntryGroupRequest actualRequest = ((GetEntryGroupRequest) actualRequests.get(0));
347 
348     Assert.assertEquals(name.toString(), actualRequest.getName());
349     Assert.assertEquals(readMask, actualRequest.getReadMask());
350     Assert.assertTrue(
351         channelProvider.isHeaderSent(
352             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
353             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
354   }
355 
356   @Test
getEntryGroupExceptionTest3()357   public void getEntryGroupExceptionTest3() throws Exception {
358     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
359     mockDataCatalog.addException(exception);
360 
361     try {
362       EntryGroupName name = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
363       FieldMask readMask = FieldMask.newBuilder().build();
364       client.getEntryGroup(name, readMask);
365       Assert.fail("No exception raised");
366     } catch (InvalidArgumentException e) {
367       // Expected exception.
368     }
369   }
370 
371   @Test
getEntryGroupTest4()372   public void getEntryGroupTest4() throws Exception {
373     EntryGroup expectedResponse =
374         EntryGroup.newBuilder()
375             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
376             .setDisplayName("displayName1714148973")
377             .setDescription("description-1724546052")
378             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
379             .build();
380     mockDataCatalog.addResponse(expectedResponse);
381 
382     String name = "name3373707";
383     FieldMask readMask = FieldMask.newBuilder().build();
384 
385     EntryGroup actualResponse = client.getEntryGroup(name, readMask);
386     Assert.assertEquals(expectedResponse, actualResponse);
387 
388     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
389     Assert.assertEquals(1, actualRequests.size());
390     GetEntryGroupRequest actualRequest = ((GetEntryGroupRequest) actualRequests.get(0));
391 
392     Assert.assertEquals(name, actualRequest.getName());
393     Assert.assertEquals(readMask, actualRequest.getReadMask());
394     Assert.assertTrue(
395         channelProvider.isHeaderSent(
396             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
397             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
398   }
399 
400   @Test
getEntryGroupExceptionTest4()401   public void getEntryGroupExceptionTest4() throws Exception {
402     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
403     mockDataCatalog.addException(exception);
404 
405     try {
406       String name = "name3373707";
407       FieldMask readMask = FieldMask.newBuilder().build();
408       client.getEntryGroup(name, readMask);
409       Assert.fail("No exception raised");
410     } catch (InvalidArgumentException e) {
411       // Expected exception.
412     }
413   }
414 
415   @Test
updateEntryGroupTest()416   public void updateEntryGroupTest() throws Exception {
417     EntryGroup expectedResponse =
418         EntryGroup.newBuilder()
419             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
420             .setDisplayName("displayName1714148973")
421             .setDescription("description-1724546052")
422             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
423             .build();
424     mockDataCatalog.addResponse(expectedResponse);
425 
426     EntryGroup entryGroup = EntryGroup.newBuilder().build();
427 
428     EntryGroup actualResponse = client.updateEntryGroup(entryGroup);
429     Assert.assertEquals(expectedResponse, actualResponse);
430 
431     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
432     Assert.assertEquals(1, actualRequests.size());
433     UpdateEntryGroupRequest actualRequest = ((UpdateEntryGroupRequest) actualRequests.get(0));
434 
435     Assert.assertEquals(entryGroup, actualRequest.getEntryGroup());
436     Assert.assertTrue(
437         channelProvider.isHeaderSent(
438             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
439             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
440   }
441 
442   @Test
updateEntryGroupExceptionTest()443   public void updateEntryGroupExceptionTest() throws Exception {
444     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
445     mockDataCatalog.addException(exception);
446 
447     try {
448       EntryGroup entryGroup = EntryGroup.newBuilder().build();
449       client.updateEntryGroup(entryGroup);
450       Assert.fail("No exception raised");
451     } catch (InvalidArgumentException e) {
452       // Expected exception.
453     }
454   }
455 
456   @Test
updateEntryGroupTest2()457   public void updateEntryGroupTest2() throws Exception {
458     EntryGroup expectedResponse =
459         EntryGroup.newBuilder()
460             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
461             .setDisplayName("displayName1714148973")
462             .setDescription("description-1724546052")
463             .setDataCatalogTimestamps(SystemTimestamps.newBuilder().build())
464             .build();
465     mockDataCatalog.addResponse(expectedResponse);
466 
467     EntryGroup entryGroup = EntryGroup.newBuilder().build();
468     FieldMask updateMask = FieldMask.newBuilder().build();
469 
470     EntryGroup actualResponse = client.updateEntryGroup(entryGroup, updateMask);
471     Assert.assertEquals(expectedResponse, actualResponse);
472 
473     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
474     Assert.assertEquals(1, actualRequests.size());
475     UpdateEntryGroupRequest actualRequest = ((UpdateEntryGroupRequest) actualRequests.get(0));
476 
477     Assert.assertEquals(entryGroup, actualRequest.getEntryGroup());
478     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
479     Assert.assertTrue(
480         channelProvider.isHeaderSent(
481             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
482             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
483   }
484 
485   @Test
updateEntryGroupExceptionTest2()486   public void updateEntryGroupExceptionTest2() throws Exception {
487     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
488     mockDataCatalog.addException(exception);
489 
490     try {
491       EntryGroup entryGroup = EntryGroup.newBuilder().build();
492       FieldMask updateMask = FieldMask.newBuilder().build();
493       client.updateEntryGroup(entryGroup, updateMask);
494       Assert.fail("No exception raised");
495     } catch (InvalidArgumentException e) {
496       // Expected exception.
497     }
498   }
499 
500   @Test
deleteEntryGroupTest()501   public void deleteEntryGroupTest() throws Exception {
502     Empty expectedResponse = Empty.newBuilder().build();
503     mockDataCatalog.addResponse(expectedResponse);
504 
505     EntryGroupName name = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
506 
507     client.deleteEntryGroup(name);
508 
509     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
510     Assert.assertEquals(1, actualRequests.size());
511     DeleteEntryGroupRequest actualRequest = ((DeleteEntryGroupRequest) actualRequests.get(0));
512 
513     Assert.assertEquals(name.toString(), actualRequest.getName());
514     Assert.assertTrue(
515         channelProvider.isHeaderSent(
516             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
517             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
518   }
519 
520   @Test
deleteEntryGroupExceptionTest()521   public void deleteEntryGroupExceptionTest() throws Exception {
522     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
523     mockDataCatalog.addException(exception);
524 
525     try {
526       EntryGroupName name = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
527       client.deleteEntryGroup(name);
528       Assert.fail("No exception raised");
529     } catch (InvalidArgumentException e) {
530       // Expected exception.
531     }
532   }
533 
534   @Test
deleteEntryGroupTest2()535   public void deleteEntryGroupTest2() throws Exception {
536     Empty expectedResponse = Empty.newBuilder().build();
537     mockDataCatalog.addResponse(expectedResponse);
538 
539     String name = "name3373707";
540 
541     client.deleteEntryGroup(name);
542 
543     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
544     Assert.assertEquals(1, actualRequests.size());
545     DeleteEntryGroupRequest actualRequest = ((DeleteEntryGroupRequest) actualRequests.get(0));
546 
547     Assert.assertEquals(name, actualRequest.getName());
548     Assert.assertTrue(
549         channelProvider.isHeaderSent(
550             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
551             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
552   }
553 
554   @Test
deleteEntryGroupExceptionTest2()555   public void deleteEntryGroupExceptionTest2() throws Exception {
556     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
557     mockDataCatalog.addException(exception);
558 
559     try {
560       String name = "name3373707";
561       client.deleteEntryGroup(name);
562       Assert.fail("No exception raised");
563     } catch (InvalidArgumentException e) {
564       // Expected exception.
565     }
566   }
567 
568   @Test
listEntryGroupsTest()569   public void listEntryGroupsTest() throws Exception {
570     EntryGroup responsesElement = EntryGroup.newBuilder().build();
571     ListEntryGroupsResponse expectedResponse =
572         ListEntryGroupsResponse.newBuilder()
573             .setNextPageToken("")
574             .addAllEntryGroups(Arrays.asList(responsesElement))
575             .build();
576     mockDataCatalog.addResponse(expectedResponse);
577 
578     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
579 
580     ListEntryGroupsPagedResponse pagedListResponse = client.listEntryGroups(parent);
581 
582     List<EntryGroup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
583 
584     Assert.assertEquals(1, resources.size());
585     Assert.assertEquals(expectedResponse.getEntryGroupsList().get(0), resources.get(0));
586 
587     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
588     Assert.assertEquals(1, actualRequests.size());
589     ListEntryGroupsRequest actualRequest = ((ListEntryGroupsRequest) actualRequests.get(0));
590 
591     Assert.assertEquals(parent.toString(), actualRequest.getParent());
592     Assert.assertTrue(
593         channelProvider.isHeaderSent(
594             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
595             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
596   }
597 
598   @Test
listEntryGroupsExceptionTest()599   public void listEntryGroupsExceptionTest() throws Exception {
600     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
601     mockDataCatalog.addException(exception);
602 
603     try {
604       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
605       client.listEntryGroups(parent);
606       Assert.fail("No exception raised");
607     } catch (InvalidArgumentException e) {
608       // Expected exception.
609     }
610   }
611 
612   @Test
listEntryGroupsTest2()613   public void listEntryGroupsTest2() throws Exception {
614     EntryGroup responsesElement = EntryGroup.newBuilder().build();
615     ListEntryGroupsResponse expectedResponse =
616         ListEntryGroupsResponse.newBuilder()
617             .setNextPageToken("")
618             .addAllEntryGroups(Arrays.asList(responsesElement))
619             .build();
620     mockDataCatalog.addResponse(expectedResponse);
621 
622     String parent = "parent-995424086";
623 
624     ListEntryGroupsPagedResponse pagedListResponse = client.listEntryGroups(parent);
625 
626     List<EntryGroup> resources = Lists.newArrayList(pagedListResponse.iterateAll());
627 
628     Assert.assertEquals(1, resources.size());
629     Assert.assertEquals(expectedResponse.getEntryGroupsList().get(0), resources.get(0));
630 
631     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
632     Assert.assertEquals(1, actualRequests.size());
633     ListEntryGroupsRequest actualRequest = ((ListEntryGroupsRequest) actualRequests.get(0));
634 
635     Assert.assertEquals(parent, actualRequest.getParent());
636     Assert.assertTrue(
637         channelProvider.isHeaderSent(
638             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
639             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
640   }
641 
642   @Test
listEntryGroupsExceptionTest2()643   public void listEntryGroupsExceptionTest2() throws Exception {
644     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
645     mockDataCatalog.addException(exception);
646 
647     try {
648       String parent = "parent-995424086";
649       client.listEntryGroups(parent);
650       Assert.fail("No exception raised");
651     } catch (InvalidArgumentException e) {
652       // Expected exception.
653     }
654   }
655 
656   @Test
createEntryTest()657   public void createEntryTest() throws Exception {
658     Entry expectedResponse =
659         Entry.newBuilder()
660             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
661             .setLinkedResource("linkedResource-495606457")
662             .setFullyQualifiedName("fullyQualifiedName288467357")
663             .setDisplayName("displayName1714148973")
664             .setDescription("description-1724546052")
665             .setBusinessContext(BusinessContext.newBuilder().build())
666             .setSchema(Schema.newBuilder().build())
667             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
668             .setUsageSignal(UsageSignal.newBuilder().build())
669             .putAllLabels(new HashMap<String, String>())
670             .setDataSource(DataSource.newBuilder().build())
671             .setPersonalDetails(PersonalDetails.newBuilder().build())
672             .build();
673     mockDataCatalog.addResponse(expectedResponse);
674 
675     EntryGroupName parent = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
676     String entryId = "entryId-1591558867";
677     Entry entry = Entry.newBuilder().build();
678 
679     Entry actualResponse = client.createEntry(parent, entryId, entry);
680     Assert.assertEquals(expectedResponse, actualResponse);
681 
682     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
683     Assert.assertEquals(1, actualRequests.size());
684     CreateEntryRequest actualRequest = ((CreateEntryRequest) actualRequests.get(0));
685 
686     Assert.assertEquals(parent.toString(), actualRequest.getParent());
687     Assert.assertEquals(entryId, actualRequest.getEntryId());
688     Assert.assertEquals(entry, actualRequest.getEntry());
689     Assert.assertTrue(
690         channelProvider.isHeaderSent(
691             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
692             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
693   }
694 
695   @Test
createEntryExceptionTest()696   public void createEntryExceptionTest() throws Exception {
697     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
698     mockDataCatalog.addException(exception);
699 
700     try {
701       EntryGroupName parent = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
702       String entryId = "entryId-1591558867";
703       Entry entry = Entry.newBuilder().build();
704       client.createEntry(parent, entryId, entry);
705       Assert.fail("No exception raised");
706     } catch (InvalidArgumentException e) {
707       // Expected exception.
708     }
709   }
710 
711   @Test
createEntryTest2()712   public void createEntryTest2() throws Exception {
713     Entry expectedResponse =
714         Entry.newBuilder()
715             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
716             .setLinkedResource("linkedResource-495606457")
717             .setFullyQualifiedName("fullyQualifiedName288467357")
718             .setDisplayName("displayName1714148973")
719             .setDescription("description-1724546052")
720             .setBusinessContext(BusinessContext.newBuilder().build())
721             .setSchema(Schema.newBuilder().build())
722             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
723             .setUsageSignal(UsageSignal.newBuilder().build())
724             .putAllLabels(new HashMap<String, String>())
725             .setDataSource(DataSource.newBuilder().build())
726             .setPersonalDetails(PersonalDetails.newBuilder().build())
727             .build();
728     mockDataCatalog.addResponse(expectedResponse);
729 
730     String parent = "parent-995424086";
731     String entryId = "entryId-1591558867";
732     Entry entry = Entry.newBuilder().build();
733 
734     Entry actualResponse = client.createEntry(parent, entryId, entry);
735     Assert.assertEquals(expectedResponse, actualResponse);
736 
737     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
738     Assert.assertEquals(1, actualRequests.size());
739     CreateEntryRequest actualRequest = ((CreateEntryRequest) actualRequests.get(0));
740 
741     Assert.assertEquals(parent, actualRequest.getParent());
742     Assert.assertEquals(entryId, actualRequest.getEntryId());
743     Assert.assertEquals(entry, actualRequest.getEntry());
744     Assert.assertTrue(
745         channelProvider.isHeaderSent(
746             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
747             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
748   }
749 
750   @Test
createEntryExceptionTest2()751   public void createEntryExceptionTest2() throws Exception {
752     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
753     mockDataCatalog.addException(exception);
754 
755     try {
756       String parent = "parent-995424086";
757       String entryId = "entryId-1591558867";
758       Entry entry = Entry.newBuilder().build();
759       client.createEntry(parent, entryId, entry);
760       Assert.fail("No exception raised");
761     } catch (InvalidArgumentException e) {
762       // Expected exception.
763     }
764   }
765 
766   @Test
updateEntryTest()767   public void updateEntryTest() throws Exception {
768     Entry expectedResponse =
769         Entry.newBuilder()
770             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
771             .setLinkedResource("linkedResource-495606457")
772             .setFullyQualifiedName("fullyQualifiedName288467357")
773             .setDisplayName("displayName1714148973")
774             .setDescription("description-1724546052")
775             .setBusinessContext(BusinessContext.newBuilder().build())
776             .setSchema(Schema.newBuilder().build())
777             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
778             .setUsageSignal(UsageSignal.newBuilder().build())
779             .putAllLabels(new HashMap<String, String>())
780             .setDataSource(DataSource.newBuilder().build())
781             .setPersonalDetails(PersonalDetails.newBuilder().build())
782             .build();
783     mockDataCatalog.addResponse(expectedResponse);
784 
785     Entry entry = Entry.newBuilder().build();
786 
787     Entry actualResponse = client.updateEntry(entry);
788     Assert.assertEquals(expectedResponse, actualResponse);
789 
790     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
791     Assert.assertEquals(1, actualRequests.size());
792     UpdateEntryRequest actualRequest = ((UpdateEntryRequest) actualRequests.get(0));
793 
794     Assert.assertEquals(entry, actualRequest.getEntry());
795     Assert.assertTrue(
796         channelProvider.isHeaderSent(
797             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
798             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
799   }
800 
801   @Test
updateEntryExceptionTest()802   public void updateEntryExceptionTest() throws Exception {
803     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
804     mockDataCatalog.addException(exception);
805 
806     try {
807       Entry entry = Entry.newBuilder().build();
808       client.updateEntry(entry);
809       Assert.fail("No exception raised");
810     } catch (InvalidArgumentException e) {
811       // Expected exception.
812     }
813   }
814 
815   @Test
updateEntryTest2()816   public void updateEntryTest2() throws Exception {
817     Entry expectedResponse =
818         Entry.newBuilder()
819             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
820             .setLinkedResource("linkedResource-495606457")
821             .setFullyQualifiedName("fullyQualifiedName288467357")
822             .setDisplayName("displayName1714148973")
823             .setDescription("description-1724546052")
824             .setBusinessContext(BusinessContext.newBuilder().build())
825             .setSchema(Schema.newBuilder().build())
826             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
827             .setUsageSignal(UsageSignal.newBuilder().build())
828             .putAllLabels(new HashMap<String, String>())
829             .setDataSource(DataSource.newBuilder().build())
830             .setPersonalDetails(PersonalDetails.newBuilder().build())
831             .build();
832     mockDataCatalog.addResponse(expectedResponse);
833 
834     Entry entry = Entry.newBuilder().build();
835     FieldMask updateMask = FieldMask.newBuilder().build();
836 
837     Entry actualResponse = client.updateEntry(entry, updateMask);
838     Assert.assertEquals(expectedResponse, actualResponse);
839 
840     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
841     Assert.assertEquals(1, actualRequests.size());
842     UpdateEntryRequest actualRequest = ((UpdateEntryRequest) actualRequests.get(0));
843 
844     Assert.assertEquals(entry, actualRequest.getEntry());
845     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
846     Assert.assertTrue(
847         channelProvider.isHeaderSent(
848             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
849             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
850   }
851 
852   @Test
updateEntryExceptionTest2()853   public void updateEntryExceptionTest2() throws Exception {
854     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
855     mockDataCatalog.addException(exception);
856 
857     try {
858       Entry entry = Entry.newBuilder().build();
859       FieldMask updateMask = FieldMask.newBuilder().build();
860       client.updateEntry(entry, updateMask);
861       Assert.fail("No exception raised");
862     } catch (InvalidArgumentException e) {
863       // Expected exception.
864     }
865   }
866 
867   @Test
deleteEntryTest()868   public void deleteEntryTest() throws Exception {
869     Empty expectedResponse = Empty.newBuilder().build();
870     mockDataCatalog.addResponse(expectedResponse);
871 
872     EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
873 
874     client.deleteEntry(name);
875 
876     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
877     Assert.assertEquals(1, actualRequests.size());
878     DeleteEntryRequest actualRequest = ((DeleteEntryRequest) actualRequests.get(0));
879 
880     Assert.assertEquals(name.toString(), actualRequest.getName());
881     Assert.assertTrue(
882         channelProvider.isHeaderSent(
883             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
884             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
885   }
886 
887   @Test
deleteEntryExceptionTest()888   public void deleteEntryExceptionTest() throws Exception {
889     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
890     mockDataCatalog.addException(exception);
891 
892     try {
893       EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
894       client.deleteEntry(name);
895       Assert.fail("No exception raised");
896     } catch (InvalidArgumentException e) {
897       // Expected exception.
898     }
899   }
900 
901   @Test
deleteEntryTest2()902   public void deleteEntryTest2() throws Exception {
903     Empty expectedResponse = Empty.newBuilder().build();
904     mockDataCatalog.addResponse(expectedResponse);
905 
906     String name = "name3373707";
907 
908     client.deleteEntry(name);
909 
910     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
911     Assert.assertEquals(1, actualRequests.size());
912     DeleteEntryRequest actualRequest = ((DeleteEntryRequest) actualRequests.get(0));
913 
914     Assert.assertEquals(name, actualRequest.getName());
915     Assert.assertTrue(
916         channelProvider.isHeaderSent(
917             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
918             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
919   }
920 
921   @Test
deleteEntryExceptionTest2()922   public void deleteEntryExceptionTest2() throws Exception {
923     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
924     mockDataCatalog.addException(exception);
925 
926     try {
927       String name = "name3373707";
928       client.deleteEntry(name);
929       Assert.fail("No exception raised");
930     } catch (InvalidArgumentException e) {
931       // Expected exception.
932     }
933   }
934 
935   @Test
getEntryTest()936   public void getEntryTest() throws Exception {
937     Entry expectedResponse =
938         Entry.newBuilder()
939             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
940             .setLinkedResource("linkedResource-495606457")
941             .setFullyQualifiedName("fullyQualifiedName288467357")
942             .setDisplayName("displayName1714148973")
943             .setDescription("description-1724546052")
944             .setBusinessContext(BusinessContext.newBuilder().build())
945             .setSchema(Schema.newBuilder().build())
946             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
947             .setUsageSignal(UsageSignal.newBuilder().build())
948             .putAllLabels(new HashMap<String, String>())
949             .setDataSource(DataSource.newBuilder().build())
950             .setPersonalDetails(PersonalDetails.newBuilder().build())
951             .build();
952     mockDataCatalog.addResponse(expectedResponse);
953 
954     EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
955 
956     Entry actualResponse = client.getEntry(name);
957     Assert.assertEquals(expectedResponse, actualResponse);
958 
959     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
960     Assert.assertEquals(1, actualRequests.size());
961     GetEntryRequest actualRequest = ((GetEntryRequest) actualRequests.get(0));
962 
963     Assert.assertEquals(name.toString(), actualRequest.getName());
964     Assert.assertTrue(
965         channelProvider.isHeaderSent(
966             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
967             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
968   }
969 
970   @Test
getEntryExceptionTest()971   public void getEntryExceptionTest() throws Exception {
972     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
973     mockDataCatalog.addException(exception);
974 
975     try {
976       EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
977       client.getEntry(name);
978       Assert.fail("No exception raised");
979     } catch (InvalidArgumentException e) {
980       // Expected exception.
981     }
982   }
983 
984   @Test
getEntryTest2()985   public void getEntryTest2() throws Exception {
986     Entry expectedResponse =
987         Entry.newBuilder()
988             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
989             .setLinkedResource("linkedResource-495606457")
990             .setFullyQualifiedName("fullyQualifiedName288467357")
991             .setDisplayName("displayName1714148973")
992             .setDescription("description-1724546052")
993             .setBusinessContext(BusinessContext.newBuilder().build())
994             .setSchema(Schema.newBuilder().build())
995             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
996             .setUsageSignal(UsageSignal.newBuilder().build())
997             .putAllLabels(new HashMap<String, String>())
998             .setDataSource(DataSource.newBuilder().build())
999             .setPersonalDetails(PersonalDetails.newBuilder().build())
1000             .build();
1001     mockDataCatalog.addResponse(expectedResponse);
1002 
1003     String name = "name3373707";
1004 
1005     Entry actualResponse = client.getEntry(name);
1006     Assert.assertEquals(expectedResponse, actualResponse);
1007 
1008     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1009     Assert.assertEquals(1, actualRequests.size());
1010     GetEntryRequest actualRequest = ((GetEntryRequest) actualRequests.get(0));
1011 
1012     Assert.assertEquals(name, actualRequest.getName());
1013     Assert.assertTrue(
1014         channelProvider.isHeaderSent(
1015             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1016             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1017   }
1018 
1019   @Test
getEntryExceptionTest2()1020   public void getEntryExceptionTest2() throws Exception {
1021     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1022     mockDataCatalog.addException(exception);
1023 
1024     try {
1025       String name = "name3373707";
1026       client.getEntry(name);
1027       Assert.fail("No exception raised");
1028     } catch (InvalidArgumentException e) {
1029       // Expected exception.
1030     }
1031   }
1032 
1033   @Test
lookupEntryTest()1034   public void lookupEntryTest() throws Exception {
1035     Entry expectedResponse =
1036         Entry.newBuilder()
1037             .setName(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
1038             .setLinkedResource("linkedResource-495606457")
1039             .setFullyQualifiedName("fullyQualifiedName288467357")
1040             .setDisplayName("displayName1714148973")
1041             .setDescription("description-1724546052")
1042             .setBusinessContext(BusinessContext.newBuilder().build())
1043             .setSchema(Schema.newBuilder().build())
1044             .setSourceSystemTimestamps(SystemTimestamps.newBuilder().build())
1045             .setUsageSignal(UsageSignal.newBuilder().build())
1046             .putAllLabels(new HashMap<String, String>())
1047             .setDataSource(DataSource.newBuilder().build())
1048             .setPersonalDetails(PersonalDetails.newBuilder().build())
1049             .build();
1050     mockDataCatalog.addResponse(expectedResponse);
1051 
1052     LookupEntryRequest request = LookupEntryRequest.newBuilder().build();
1053 
1054     Entry actualResponse = client.lookupEntry(request);
1055     Assert.assertEquals(expectedResponse, actualResponse);
1056 
1057     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1058     Assert.assertEquals(1, actualRequests.size());
1059     LookupEntryRequest actualRequest = ((LookupEntryRequest) actualRequests.get(0));
1060 
1061     Assert.assertEquals(request.getLinkedResource(), actualRequest.getLinkedResource());
1062     Assert.assertEquals(request.getSqlResource(), actualRequest.getSqlResource());
1063     Assert.assertEquals(request.getFullyQualifiedName(), actualRequest.getFullyQualifiedName());
1064     Assert.assertTrue(
1065         channelProvider.isHeaderSent(
1066             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1067             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1068   }
1069 
1070   @Test
lookupEntryExceptionTest()1071   public void lookupEntryExceptionTest() throws Exception {
1072     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1073     mockDataCatalog.addException(exception);
1074 
1075     try {
1076       LookupEntryRequest request = LookupEntryRequest.newBuilder().build();
1077       client.lookupEntry(request);
1078       Assert.fail("No exception raised");
1079     } catch (InvalidArgumentException e) {
1080       // Expected exception.
1081     }
1082   }
1083 
1084   @Test
listEntriesTest()1085   public void listEntriesTest() throws Exception {
1086     Entry responsesElement = Entry.newBuilder().build();
1087     ListEntriesResponse expectedResponse =
1088         ListEntriesResponse.newBuilder()
1089             .setNextPageToken("")
1090             .addAllEntries(Arrays.asList(responsesElement))
1091             .build();
1092     mockDataCatalog.addResponse(expectedResponse);
1093 
1094     EntryGroupName parent = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
1095 
1096     ListEntriesPagedResponse pagedListResponse = client.listEntries(parent);
1097 
1098     List<Entry> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1099 
1100     Assert.assertEquals(1, resources.size());
1101     Assert.assertEquals(expectedResponse.getEntriesList().get(0), resources.get(0));
1102 
1103     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1104     Assert.assertEquals(1, actualRequests.size());
1105     ListEntriesRequest actualRequest = ((ListEntriesRequest) actualRequests.get(0));
1106 
1107     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1108     Assert.assertTrue(
1109         channelProvider.isHeaderSent(
1110             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1111             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1112   }
1113 
1114   @Test
listEntriesExceptionTest()1115   public void listEntriesExceptionTest() throws Exception {
1116     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1117     mockDataCatalog.addException(exception);
1118 
1119     try {
1120       EntryGroupName parent = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
1121       client.listEntries(parent);
1122       Assert.fail("No exception raised");
1123     } catch (InvalidArgumentException e) {
1124       // Expected exception.
1125     }
1126   }
1127 
1128   @Test
listEntriesTest2()1129   public void listEntriesTest2() throws Exception {
1130     Entry responsesElement = Entry.newBuilder().build();
1131     ListEntriesResponse expectedResponse =
1132         ListEntriesResponse.newBuilder()
1133             .setNextPageToken("")
1134             .addAllEntries(Arrays.asList(responsesElement))
1135             .build();
1136     mockDataCatalog.addResponse(expectedResponse);
1137 
1138     String parent = "parent-995424086";
1139 
1140     ListEntriesPagedResponse pagedListResponse = client.listEntries(parent);
1141 
1142     List<Entry> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1143 
1144     Assert.assertEquals(1, resources.size());
1145     Assert.assertEquals(expectedResponse.getEntriesList().get(0), resources.get(0));
1146 
1147     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1148     Assert.assertEquals(1, actualRequests.size());
1149     ListEntriesRequest actualRequest = ((ListEntriesRequest) actualRequests.get(0));
1150 
1151     Assert.assertEquals(parent, actualRequest.getParent());
1152     Assert.assertTrue(
1153         channelProvider.isHeaderSent(
1154             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1155             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1156   }
1157 
1158   @Test
listEntriesExceptionTest2()1159   public void listEntriesExceptionTest2() throws Exception {
1160     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1161     mockDataCatalog.addException(exception);
1162 
1163     try {
1164       String parent = "parent-995424086";
1165       client.listEntries(parent);
1166       Assert.fail("No exception raised");
1167     } catch (InvalidArgumentException e) {
1168       // Expected exception.
1169     }
1170   }
1171 
1172   @Test
modifyEntryOverviewTest()1173   public void modifyEntryOverviewTest() throws Exception {
1174     EntryOverview expectedResponse =
1175         EntryOverview.newBuilder().setOverview("overview530115961").build();
1176     mockDataCatalog.addResponse(expectedResponse);
1177 
1178     ModifyEntryOverviewRequest request =
1179         ModifyEntryOverviewRequest.newBuilder()
1180             .setName(EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
1181             .setEntryOverview(EntryOverview.newBuilder().build())
1182             .build();
1183 
1184     EntryOverview actualResponse = client.modifyEntryOverview(request);
1185     Assert.assertEquals(expectedResponse, actualResponse);
1186 
1187     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1188     Assert.assertEquals(1, actualRequests.size());
1189     ModifyEntryOverviewRequest actualRequest = ((ModifyEntryOverviewRequest) actualRequests.get(0));
1190 
1191     Assert.assertEquals(request.getName(), actualRequest.getName());
1192     Assert.assertEquals(request.getEntryOverview(), actualRequest.getEntryOverview());
1193     Assert.assertTrue(
1194         channelProvider.isHeaderSent(
1195             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1196             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1197   }
1198 
1199   @Test
modifyEntryOverviewExceptionTest()1200   public void modifyEntryOverviewExceptionTest() throws Exception {
1201     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1202     mockDataCatalog.addException(exception);
1203 
1204     try {
1205       ModifyEntryOverviewRequest request =
1206           ModifyEntryOverviewRequest.newBuilder()
1207               .setName(
1208                   EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
1209               .setEntryOverview(EntryOverview.newBuilder().build())
1210               .build();
1211       client.modifyEntryOverview(request);
1212       Assert.fail("No exception raised");
1213     } catch (InvalidArgumentException e) {
1214       // Expected exception.
1215     }
1216   }
1217 
1218   @Test
modifyEntryContactsTest()1219   public void modifyEntryContactsTest() throws Exception {
1220     Contacts expectedResponse =
1221         Contacts.newBuilder().addAllPeople(new ArrayList<Contacts.Person>()).build();
1222     mockDataCatalog.addResponse(expectedResponse);
1223 
1224     ModifyEntryContactsRequest request =
1225         ModifyEntryContactsRequest.newBuilder()
1226             .setName(EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
1227             .setContacts(Contacts.newBuilder().build())
1228             .build();
1229 
1230     Contacts actualResponse = client.modifyEntryContacts(request);
1231     Assert.assertEquals(expectedResponse, actualResponse);
1232 
1233     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1234     Assert.assertEquals(1, actualRequests.size());
1235     ModifyEntryContactsRequest actualRequest = ((ModifyEntryContactsRequest) actualRequests.get(0));
1236 
1237     Assert.assertEquals(request.getName(), actualRequest.getName());
1238     Assert.assertEquals(request.getContacts(), actualRequest.getContacts());
1239     Assert.assertTrue(
1240         channelProvider.isHeaderSent(
1241             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1242             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1243   }
1244 
1245   @Test
modifyEntryContactsExceptionTest()1246   public void modifyEntryContactsExceptionTest() throws Exception {
1247     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1248     mockDataCatalog.addException(exception);
1249 
1250     try {
1251       ModifyEntryContactsRequest request =
1252           ModifyEntryContactsRequest.newBuilder()
1253               .setName(
1254                   EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
1255               .setContacts(Contacts.newBuilder().build())
1256               .build();
1257       client.modifyEntryContacts(request);
1258       Assert.fail("No exception raised");
1259     } catch (InvalidArgumentException e) {
1260       // Expected exception.
1261     }
1262   }
1263 
1264   @Test
createTagTemplateTest()1265   public void createTagTemplateTest() throws Exception {
1266     TagTemplate expectedResponse =
1267         TagTemplate.newBuilder()
1268             .setName(TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
1269             .setDisplayName("displayName1714148973")
1270             .setIsPubliclyReadable(true)
1271             .putAllFields(new HashMap<String, TagTemplateField>())
1272             .build();
1273     mockDataCatalog.addResponse(expectedResponse);
1274 
1275     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1276     String tagTemplateId = "tagTemplateId-1438776721";
1277     TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1278 
1279     TagTemplate actualResponse = client.createTagTemplate(parent, tagTemplateId, tagTemplate);
1280     Assert.assertEquals(expectedResponse, actualResponse);
1281 
1282     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1283     Assert.assertEquals(1, actualRequests.size());
1284     CreateTagTemplateRequest actualRequest = ((CreateTagTemplateRequest) actualRequests.get(0));
1285 
1286     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1287     Assert.assertEquals(tagTemplateId, actualRequest.getTagTemplateId());
1288     Assert.assertEquals(tagTemplate, actualRequest.getTagTemplate());
1289     Assert.assertTrue(
1290         channelProvider.isHeaderSent(
1291             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1292             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1293   }
1294 
1295   @Test
createTagTemplateExceptionTest()1296   public void createTagTemplateExceptionTest() throws Exception {
1297     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1298     mockDataCatalog.addException(exception);
1299 
1300     try {
1301       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1302       String tagTemplateId = "tagTemplateId-1438776721";
1303       TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1304       client.createTagTemplate(parent, tagTemplateId, tagTemplate);
1305       Assert.fail("No exception raised");
1306     } catch (InvalidArgumentException e) {
1307       // Expected exception.
1308     }
1309   }
1310 
1311   @Test
createTagTemplateTest2()1312   public void createTagTemplateTest2() throws Exception {
1313     TagTemplate expectedResponse =
1314         TagTemplate.newBuilder()
1315             .setName(TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
1316             .setDisplayName("displayName1714148973")
1317             .setIsPubliclyReadable(true)
1318             .putAllFields(new HashMap<String, TagTemplateField>())
1319             .build();
1320     mockDataCatalog.addResponse(expectedResponse);
1321 
1322     String parent = "parent-995424086";
1323     String tagTemplateId = "tagTemplateId-1438776721";
1324     TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1325 
1326     TagTemplate actualResponse = client.createTagTemplate(parent, tagTemplateId, tagTemplate);
1327     Assert.assertEquals(expectedResponse, actualResponse);
1328 
1329     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1330     Assert.assertEquals(1, actualRequests.size());
1331     CreateTagTemplateRequest actualRequest = ((CreateTagTemplateRequest) actualRequests.get(0));
1332 
1333     Assert.assertEquals(parent, actualRequest.getParent());
1334     Assert.assertEquals(tagTemplateId, actualRequest.getTagTemplateId());
1335     Assert.assertEquals(tagTemplate, actualRequest.getTagTemplate());
1336     Assert.assertTrue(
1337         channelProvider.isHeaderSent(
1338             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1339             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1340   }
1341 
1342   @Test
createTagTemplateExceptionTest2()1343   public void createTagTemplateExceptionTest2() throws Exception {
1344     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1345     mockDataCatalog.addException(exception);
1346 
1347     try {
1348       String parent = "parent-995424086";
1349       String tagTemplateId = "tagTemplateId-1438776721";
1350       TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1351       client.createTagTemplate(parent, tagTemplateId, tagTemplate);
1352       Assert.fail("No exception raised");
1353     } catch (InvalidArgumentException e) {
1354       // Expected exception.
1355     }
1356   }
1357 
1358   @Test
getTagTemplateTest()1359   public void getTagTemplateTest() throws Exception {
1360     TagTemplate expectedResponse =
1361         TagTemplate.newBuilder()
1362             .setName(TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
1363             .setDisplayName("displayName1714148973")
1364             .setIsPubliclyReadable(true)
1365             .putAllFields(new HashMap<String, TagTemplateField>())
1366             .build();
1367     mockDataCatalog.addResponse(expectedResponse);
1368 
1369     TagTemplateName name = TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]");
1370 
1371     TagTemplate actualResponse = client.getTagTemplate(name);
1372     Assert.assertEquals(expectedResponse, actualResponse);
1373 
1374     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1375     Assert.assertEquals(1, actualRequests.size());
1376     GetTagTemplateRequest actualRequest = ((GetTagTemplateRequest) actualRequests.get(0));
1377 
1378     Assert.assertEquals(name.toString(), actualRequest.getName());
1379     Assert.assertTrue(
1380         channelProvider.isHeaderSent(
1381             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1382             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1383   }
1384 
1385   @Test
getTagTemplateExceptionTest()1386   public void getTagTemplateExceptionTest() throws Exception {
1387     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1388     mockDataCatalog.addException(exception);
1389 
1390     try {
1391       TagTemplateName name = TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]");
1392       client.getTagTemplate(name);
1393       Assert.fail("No exception raised");
1394     } catch (InvalidArgumentException e) {
1395       // Expected exception.
1396     }
1397   }
1398 
1399   @Test
getTagTemplateTest2()1400   public void getTagTemplateTest2() throws Exception {
1401     TagTemplate expectedResponse =
1402         TagTemplate.newBuilder()
1403             .setName(TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
1404             .setDisplayName("displayName1714148973")
1405             .setIsPubliclyReadable(true)
1406             .putAllFields(new HashMap<String, TagTemplateField>())
1407             .build();
1408     mockDataCatalog.addResponse(expectedResponse);
1409 
1410     String name = "name3373707";
1411 
1412     TagTemplate actualResponse = client.getTagTemplate(name);
1413     Assert.assertEquals(expectedResponse, actualResponse);
1414 
1415     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1416     Assert.assertEquals(1, actualRequests.size());
1417     GetTagTemplateRequest actualRequest = ((GetTagTemplateRequest) actualRequests.get(0));
1418 
1419     Assert.assertEquals(name, actualRequest.getName());
1420     Assert.assertTrue(
1421         channelProvider.isHeaderSent(
1422             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1423             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1424   }
1425 
1426   @Test
getTagTemplateExceptionTest2()1427   public void getTagTemplateExceptionTest2() throws Exception {
1428     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1429     mockDataCatalog.addException(exception);
1430 
1431     try {
1432       String name = "name3373707";
1433       client.getTagTemplate(name);
1434       Assert.fail("No exception raised");
1435     } catch (InvalidArgumentException e) {
1436       // Expected exception.
1437     }
1438   }
1439 
1440   @Test
updateTagTemplateTest()1441   public void updateTagTemplateTest() throws Exception {
1442     TagTemplate expectedResponse =
1443         TagTemplate.newBuilder()
1444             .setName(TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
1445             .setDisplayName("displayName1714148973")
1446             .setIsPubliclyReadable(true)
1447             .putAllFields(new HashMap<String, TagTemplateField>())
1448             .build();
1449     mockDataCatalog.addResponse(expectedResponse);
1450 
1451     TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1452 
1453     TagTemplate actualResponse = client.updateTagTemplate(tagTemplate);
1454     Assert.assertEquals(expectedResponse, actualResponse);
1455 
1456     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1457     Assert.assertEquals(1, actualRequests.size());
1458     UpdateTagTemplateRequest actualRequest = ((UpdateTagTemplateRequest) actualRequests.get(0));
1459 
1460     Assert.assertEquals(tagTemplate, actualRequest.getTagTemplate());
1461     Assert.assertTrue(
1462         channelProvider.isHeaderSent(
1463             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1464             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1465   }
1466 
1467   @Test
updateTagTemplateExceptionTest()1468   public void updateTagTemplateExceptionTest() throws Exception {
1469     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1470     mockDataCatalog.addException(exception);
1471 
1472     try {
1473       TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1474       client.updateTagTemplate(tagTemplate);
1475       Assert.fail("No exception raised");
1476     } catch (InvalidArgumentException e) {
1477       // Expected exception.
1478     }
1479   }
1480 
1481   @Test
updateTagTemplateTest2()1482   public void updateTagTemplateTest2() throws Exception {
1483     TagTemplate expectedResponse =
1484         TagTemplate.newBuilder()
1485             .setName(TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
1486             .setDisplayName("displayName1714148973")
1487             .setIsPubliclyReadable(true)
1488             .putAllFields(new HashMap<String, TagTemplateField>())
1489             .build();
1490     mockDataCatalog.addResponse(expectedResponse);
1491 
1492     TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1493     FieldMask updateMask = FieldMask.newBuilder().build();
1494 
1495     TagTemplate actualResponse = client.updateTagTemplate(tagTemplate, updateMask);
1496     Assert.assertEquals(expectedResponse, actualResponse);
1497 
1498     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1499     Assert.assertEquals(1, actualRequests.size());
1500     UpdateTagTemplateRequest actualRequest = ((UpdateTagTemplateRequest) actualRequests.get(0));
1501 
1502     Assert.assertEquals(tagTemplate, actualRequest.getTagTemplate());
1503     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1504     Assert.assertTrue(
1505         channelProvider.isHeaderSent(
1506             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1507             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1508   }
1509 
1510   @Test
updateTagTemplateExceptionTest2()1511   public void updateTagTemplateExceptionTest2() throws Exception {
1512     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1513     mockDataCatalog.addException(exception);
1514 
1515     try {
1516       TagTemplate tagTemplate = TagTemplate.newBuilder().build();
1517       FieldMask updateMask = FieldMask.newBuilder().build();
1518       client.updateTagTemplate(tagTemplate, updateMask);
1519       Assert.fail("No exception raised");
1520     } catch (InvalidArgumentException e) {
1521       // Expected exception.
1522     }
1523   }
1524 
1525   @Test
deleteTagTemplateTest()1526   public void deleteTagTemplateTest() throws Exception {
1527     Empty expectedResponse = Empty.newBuilder().build();
1528     mockDataCatalog.addResponse(expectedResponse);
1529 
1530     TagTemplateName name = TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]");
1531     boolean force = true;
1532 
1533     client.deleteTagTemplate(name, force);
1534 
1535     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1536     Assert.assertEquals(1, actualRequests.size());
1537     DeleteTagTemplateRequest actualRequest = ((DeleteTagTemplateRequest) actualRequests.get(0));
1538 
1539     Assert.assertEquals(name.toString(), actualRequest.getName());
1540     Assert.assertEquals(force, actualRequest.getForce());
1541     Assert.assertTrue(
1542         channelProvider.isHeaderSent(
1543             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1544             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1545   }
1546 
1547   @Test
deleteTagTemplateExceptionTest()1548   public void deleteTagTemplateExceptionTest() throws Exception {
1549     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1550     mockDataCatalog.addException(exception);
1551 
1552     try {
1553       TagTemplateName name = TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]");
1554       boolean force = true;
1555       client.deleteTagTemplate(name, force);
1556       Assert.fail("No exception raised");
1557     } catch (InvalidArgumentException e) {
1558       // Expected exception.
1559     }
1560   }
1561 
1562   @Test
deleteTagTemplateTest2()1563   public void deleteTagTemplateTest2() throws Exception {
1564     Empty expectedResponse = Empty.newBuilder().build();
1565     mockDataCatalog.addResponse(expectedResponse);
1566 
1567     String name = "name3373707";
1568     boolean force = true;
1569 
1570     client.deleteTagTemplate(name, force);
1571 
1572     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1573     Assert.assertEquals(1, actualRequests.size());
1574     DeleteTagTemplateRequest actualRequest = ((DeleteTagTemplateRequest) actualRequests.get(0));
1575 
1576     Assert.assertEquals(name, actualRequest.getName());
1577     Assert.assertEquals(force, actualRequest.getForce());
1578     Assert.assertTrue(
1579         channelProvider.isHeaderSent(
1580             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1581             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1582   }
1583 
1584   @Test
deleteTagTemplateExceptionTest2()1585   public void deleteTagTemplateExceptionTest2() throws Exception {
1586     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1587     mockDataCatalog.addException(exception);
1588 
1589     try {
1590       String name = "name3373707";
1591       boolean force = true;
1592       client.deleteTagTemplate(name, force);
1593       Assert.fail("No exception raised");
1594     } catch (InvalidArgumentException e) {
1595       // Expected exception.
1596     }
1597   }
1598 
1599   @Test
createTagTemplateFieldTest()1600   public void createTagTemplateFieldTest() throws Exception {
1601     TagTemplateField expectedResponse =
1602         TagTemplateField.newBuilder()
1603             .setName(
1604                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1605                     .toString())
1606             .setDisplayName("displayName1714148973")
1607             .setType(FieldType.newBuilder().build())
1608             .setIsRequired(true)
1609             .setDescription("description-1724546052")
1610             .setOrder(106006350)
1611             .build();
1612     mockDataCatalog.addResponse(expectedResponse);
1613 
1614     TagTemplateName parent = TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]");
1615     String tagTemplateFieldId = "tagTemplateFieldId-1556835615";
1616     TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1617 
1618     TagTemplateField actualResponse =
1619         client.createTagTemplateField(parent, tagTemplateFieldId, tagTemplateField);
1620     Assert.assertEquals(expectedResponse, actualResponse);
1621 
1622     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1623     Assert.assertEquals(1, actualRequests.size());
1624     CreateTagTemplateFieldRequest actualRequest =
1625         ((CreateTagTemplateFieldRequest) actualRequests.get(0));
1626 
1627     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1628     Assert.assertEquals(tagTemplateFieldId, actualRequest.getTagTemplateFieldId());
1629     Assert.assertEquals(tagTemplateField, actualRequest.getTagTemplateField());
1630     Assert.assertTrue(
1631         channelProvider.isHeaderSent(
1632             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1633             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1634   }
1635 
1636   @Test
createTagTemplateFieldExceptionTest()1637   public void createTagTemplateFieldExceptionTest() throws Exception {
1638     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1639     mockDataCatalog.addException(exception);
1640 
1641     try {
1642       TagTemplateName parent = TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]");
1643       String tagTemplateFieldId = "tagTemplateFieldId-1556835615";
1644       TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1645       client.createTagTemplateField(parent, tagTemplateFieldId, tagTemplateField);
1646       Assert.fail("No exception raised");
1647     } catch (InvalidArgumentException e) {
1648       // Expected exception.
1649     }
1650   }
1651 
1652   @Test
createTagTemplateFieldTest2()1653   public void createTagTemplateFieldTest2() throws Exception {
1654     TagTemplateField expectedResponse =
1655         TagTemplateField.newBuilder()
1656             .setName(
1657                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1658                     .toString())
1659             .setDisplayName("displayName1714148973")
1660             .setType(FieldType.newBuilder().build())
1661             .setIsRequired(true)
1662             .setDescription("description-1724546052")
1663             .setOrder(106006350)
1664             .build();
1665     mockDataCatalog.addResponse(expectedResponse);
1666 
1667     String parent = "parent-995424086";
1668     String tagTemplateFieldId = "tagTemplateFieldId-1556835615";
1669     TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1670 
1671     TagTemplateField actualResponse =
1672         client.createTagTemplateField(parent, tagTemplateFieldId, tagTemplateField);
1673     Assert.assertEquals(expectedResponse, actualResponse);
1674 
1675     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1676     Assert.assertEquals(1, actualRequests.size());
1677     CreateTagTemplateFieldRequest actualRequest =
1678         ((CreateTagTemplateFieldRequest) actualRequests.get(0));
1679 
1680     Assert.assertEquals(parent, actualRequest.getParent());
1681     Assert.assertEquals(tagTemplateFieldId, actualRequest.getTagTemplateFieldId());
1682     Assert.assertEquals(tagTemplateField, actualRequest.getTagTemplateField());
1683     Assert.assertTrue(
1684         channelProvider.isHeaderSent(
1685             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1686             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1687   }
1688 
1689   @Test
createTagTemplateFieldExceptionTest2()1690   public void createTagTemplateFieldExceptionTest2() throws Exception {
1691     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1692     mockDataCatalog.addException(exception);
1693 
1694     try {
1695       String parent = "parent-995424086";
1696       String tagTemplateFieldId = "tagTemplateFieldId-1556835615";
1697       TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1698       client.createTagTemplateField(parent, tagTemplateFieldId, tagTemplateField);
1699       Assert.fail("No exception raised");
1700     } catch (InvalidArgumentException e) {
1701       // Expected exception.
1702     }
1703   }
1704 
1705   @Test
updateTagTemplateFieldTest()1706   public void updateTagTemplateFieldTest() throws Exception {
1707     TagTemplateField expectedResponse =
1708         TagTemplateField.newBuilder()
1709             .setName(
1710                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1711                     .toString())
1712             .setDisplayName("displayName1714148973")
1713             .setType(FieldType.newBuilder().build())
1714             .setIsRequired(true)
1715             .setDescription("description-1724546052")
1716             .setOrder(106006350)
1717             .build();
1718     mockDataCatalog.addResponse(expectedResponse);
1719 
1720     TagTemplateFieldName name =
1721         TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
1722     TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1723 
1724     TagTemplateField actualResponse = client.updateTagTemplateField(name, tagTemplateField);
1725     Assert.assertEquals(expectedResponse, actualResponse);
1726 
1727     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1728     Assert.assertEquals(1, actualRequests.size());
1729     UpdateTagTemplateFieldRequest actualRequest =
1730         ((UpdateTagTemplateFieldRequest) actualRequests.get(0));
1731 
1732     Assert.assertEquals(name.toString(), actualRequest.getName());
1733     Assert.assertEquals(tagTemplateField, actualRequest.getTagTemplateField());
1734     Assert.assertTrue(
1735         channelProvider.isHeaderSent(
1736             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1737             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1738   }
1739 
1740   @Test
updateTagTemplateFieldExceptionTest()1741   public void updateTagTemplateFieldExceptionTest() throws Exception {
1742     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1743     mockDataCatalog.addException(exception);
1744 
1745     try {
1746       TagTemplateFieldName name =
1747           TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
1748       TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1749       client.updateTagTemplateField(name, tagTemplateField);
1750       Assert.fail("No exception raised");
1751     } catch (InvalidArgumentException e) {
1752       // Expected exception.
1753     }
1754   }
1755 
1756   @Test
updateTagTemplateFieldTest2()1757   public void updateTagTemplateFieldTest2() throws Exception {
1758     TagTemplateField expectedResponse =
1759         TagTemplateField.newBuilder()
1760             .setName(
1761                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1762                     .toString())
1763             .setDisplayName("displayName1714148973")
1764             .setType(FieldType.newBuilder().build())
1765             .setIsRequired(true)
1766             .setDescription("description-1724546052")
1767             .setOrder(106006350)
1768             .build();
1769     mockDataCatalog.addResponse(expectedResponse);
1770 
1771     String name = "name3373707";
1772     TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1773 
1774     TagTemplateField actualResponse = client.updateTagTemplateField(name, tagTemplateField);
1775     Assert.assertEquals(expectedResponse, actualResponse);
1776 
1777     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1778     Assert.assertEquals(1, actualRequests.size());
1779     UpdateTagTemplateFieldRequest actualRequest =
1780         ((UpdateTagTemplateFieldRequest) actualRequests.get(0));
1781 
1782     Assert.assertEquals(name, actualRequest.getName());
1783     Assert.assertEquals(tagTemplateField, actualRequest.getTagTemplateField());
1784     Assert.assertTrue(
1785         channelProvider.isHeaderSent(
1786             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1787             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1788   }
1789 
1790   @Test
updateTagTemplateFieldExceptionTest2()1791   public void updateTagTemplateFieldExceptionTest2() throws Exception {
1792     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1793     mockDataCatalog.addException(exception);
1794 
1795     try {
1796       String name = "name3373707";
1797       TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1798       client.updateTagTemplateField(name, tagTemplateField);
1799       Assert.fail("No exception raised");
1800     } catch (InvalidArgumentException e) {
1801       // Expected exception.
1802     }
1803   }
1804 
1805   @Test
updateTagTemplateFieldTest3()1806   public void updateTagTemplateFieldTest3() throws Exception {
1807     TagTemplateField expectedResponse =
1808         TagTemplateField.newBuilder()
1809             .setName(
1810                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1811                     .toString())
1812             .setDisplayName("displayName1714148973")
1813             .setType(FieldType.newBuilder().build())
1814             .setIsRequired(true)
1815             .setDescription("description-1724546052")
1816             .setOrder(106006350)
1817             .build();
1818     mockDataCatalog.addResponse(expectedResponse);
1819 
1820     TagTemplateFieldName name =
1821         TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
1822     TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1823     FieldMask updateMask = FieldMask.newBuilder().build();
1824 
1825     TagTemplateField actualResponse =
1826         client.updateTagTemplateField(name, tagTemplateField, updateMask);
1827     Assert.assertEquals(expectedResponse, actualResponse);
1828 
1829     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1830     Assert.assertEquals(1, actualRequests.size());
1831     UpdateTagTemplateFieldRequest actualRequest =
1832         ((UpdateTagTemplateFieldRequest) actualRequests.get(0));
1833 
1834     Assert.assertEquals(name.toString(), actualRequest.getName());
1835     Assert.assertEquals(tagTemplateField, actualRequest.getTagTemplateField());
1836     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1837     Assert.assertTrue(
1838         channelProvider.isHeaderSent(
1839             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1840             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1841   }
1842 
1843   @Test
updateTagTemplateFieldExceptionTest3()1844   public void updateTagTemplateFieldExceptionTest3() throws Exception {
1845     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1846     mockDataCatalog.addException(exception);
1847 
1848     try {
1849       TagTemplateFieldName name =
1850           TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
1851       TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1852       FieldMask updateMask = FieldMask.newBuilder().build();
1853       client.updateTagTemplateField(name, tagTemplateField, updateMask);
1854       Assert.fail("No exception raised");
1855     } catch (InvalidArgumentException e) {
1856       // Expected exception.
1857     }
1858   }
1859 
1860   @Test
updateTagTemplateFieldTest4()1861   public void updateTagTemplateFieldTest4() throws Exception {
1862     TagTemplateField expectedResponse =
1863         TagTemplateField.newBuilder()
1864             .setName(
1865                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1866                     .toString())
1867             .setDisplayName("displayName1714148973")
1868             .setType(FieldType.newBuilder().build())
1869             .setIsRequired(true)
1870             .setDescription("description-1724546052")
1871             .setOrder(106006350)
1872             .build();
1873     mockDataCatalog.addResponse(expectedResponse);
1874 
1875     String name = "name3373707";
1876     TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1877     FieldMask updateMask = FieldMask.newBuilder().build();
1878 
1879     TagTemplateField actualResponse =
1880         client.updateTagTemplateField(name, tagTemplateField, updateMask);
1881     Assert.assertEquals(expectedResponse, actualResponse);
1882 
1883     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1884     Assert.assertEquals(1, actualRequests.size());
1885     UpdateTagTemplateFieldRequest actualRequest =
1886         ((UpdateTagTemplateFieldRequest) actualRequests.get(0));
1887 
1888     Assert.assertEquals(name, actualRequest.getName());
1889     Assert.assertEquals(tagTemplateField, actualRequest.getTagTemplateField());
1890     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1891     Assert.assertTrue(
1892         channelProvider.isHeaderSent(
1893             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1894             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1895   }
1896 
1897   @Test
updateTagTemplateFieldExceptionTest4()1898   public void updateTagTemplateFieldExceptionTest4() throws Exception {
1899     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1900     mockDataCatalog.addException(exception);
1901 
1902     try {
1903       String name = "name3373707";
1904       TagTemplateField tagTemplateField = TagTemplateField.newBuilder().build();
1905       FieldMask updateMask = FieldMask.newBuilder().build();
1906       client.updateTagTemplateField(name, tagTemplateField, updateMask);
1907       Assert.fail("No exception raised");
1908     } catch (InvalidArgumentException e) {
1909       // Expected exception.
1910     }
1911   }
1912 
1913   @Test
renameTagTemplateFieldTest()1914   public void renameTagTemplateFieldTest() throws Exception {
1915     TagTemplateField expectedResponse =
1916         TagTemplateField.newBuilder()
1917             .setName(
1918                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1919                     .toString())
1920             .setDisplayName("displayName1714148973")
1921             .setType(FieldType.newBuilder().build())
1922             .setIsRequired(true)
1923             .setDescription("description-1724546052")
1924             .setOrder(106006350)
1925             .build();
1926     mockDataCatalog.addResponse(expectedResponse);
1927 
1928     TagTemplateFieldName name =
1929         TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
1930     String newTagTemplateFieldId = "newTagTemplateFieldId2008993953";
1931 
1932     TagTemplateField actualResponse = client.renameTagTemplateField(name, newTagTemplateFieldId);
1933     Assert.assertEquals(expectedResponse, actualResponse);
1934 
1935     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1936     Assert.assertEquals(1, actualRequests.size());
1937     RenameTagTemplateFieldRequest actualRequest =
1938         ((RenameTagTemplateFieldRequest) actualRequests.get(0));
1939 
1940     Assert.assertEquals(name.toString(), actualRequest.getName());
1941     Assert.assertEquals(newTagTemplateFieldId, actualRequest.getNewTagTemplateFieldId());
1942     Assert.assertTrue(
1943         channelProvider.isHeaderSent(
1944             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1945             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1946   }
1947 
1948   @Test
renameTagTemplateFieldExceptionTest()1949   public void renameTagTemplateFieldExceptionTest() throws Exception {
1950     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1951     mockDataCatalog.addException(exception);
1952 
1953     try {
1954       TagTemplateFieldName name =
1955           TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
1956       String newTagTemplateFieldId = "newTagTemplateFieldId2008993953";
1957       client.renameTagTemplateField(name, newTagTemplateFieldId);
1958       Assert.fail("No exception raised");
1959     } catch (InvalidArgumentException e) {
1960       // Expected exception.
1961     }
1962   }
1963 
1964   @Test
renameTagTemplateFieldTest2()1965   public void renameTagTemplateFieldTest2() throws Exception {
1966     TagTemplateField expectedResponse =
1967         TagTemplateField.newBuilder()
1968             .setName(
1969                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
1970                     .toString())
1971             .setDisplayName("displayName1714148973")
1972             .setType(FieldType.newBuilder().build())
1973             .setIsRequired(true)
1974             .setDescription("description-1724546052")
1975             .setOrder(106006350)
1976             .build();
1977     mockDataCatalog.addResponse(expectedResponse);
1978 
1979     String name = "name3373707";
1980     String newTagTemplateFieldId = "newTagTemplateFieldId2008993953";
1981 
1982     TagTemplateField actualResponse = client.renameTagTemplateField(name, newTagTemplateFieldId);
1983     Assert.assertEquals(expectedResponse, actualResponse);
1984 
1985     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
1986     Assert.assertEquals(1, actualRequests.size());
1987     RenameTagTemplateFieldRequest actualRequest =
1988         ((RenameTagTemplateFieldRequest) actualRequests.get(0));
1989 
1990     Assert.assertEquals(name, actualRequest.getName());
1991     Assert.assertEquals(newTagTemplateFieldId, actualRequest.getNewTagTemplateFieldId());
1992     Assert.assertTrue(
1993         channelProvider.isHeaderSent(
1994             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1995             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1996   }
1997 
1998   @Test
renameTagTemplateFieldExceptionTest2()1999   public void renameTagTemplateFieldExceptionTest2() throws Exception {
2000     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2001     mockDataCatalog.addException(exception);
2002 
2003     try {
2004       String name = "name3373707";
2005       String newTagTemplateFieldId = "newTagTemplateFieldId2008993953";
2006       client.renameTagTemplateField(name, newTagTemplateFieldId);
2007       Assert.fail("No exception raised");
2008     } catch (InvalidArgumentException e) {
2009       // Expected exception.
2010     }
2011   }
2012 
2013   @Test
renameTagTemplateFieldEnumValueTest()2014   public void renameTagTemplateFieldEnumValueTest() throws Exception {
2015     TagTemplateField expectedResponse =
2016         TagTemplateField.newBuilder()
2017             .setName(
2018                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
2019                     .toString())
2020             .setDisplayName("displayName1714148973")
2021             .setType(FieldType.newBuilder().build())
2022             .setIsRequired(true)
2023             .setDescription("description-1724546052")
2024             .setOrder(106006350)
2025             .build();
2026     mockDataCatalog.addResponse(expectedResponse);
2027 
2028     TagTemplateFieldEnumValueName name =
2029         TagTemplateFieldEnumValueName.of(
2030             "[PROJECT]",
2031             "[LOCATION]",
2032             "[TAG_TEMPLATE]",
2033             "[TAG_TEMPLATE_FIELD_ID]",
2034             "[ENUM_VALUE_DISPLAY_NAME]");
2035     String newEnumValueDisplayName = "newEnumValueDisplayName-1119629027";
2036 
2037     TagTemplateField actualResponse =
2038         client.renameTagTemplateFieldEnumValue(name, newEnumValueDisplayName);
2039     Assert.assertEquals(expectedResponse, actualResponse);
2040 
2041     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2042     Assert.assertEquals(1, actualRequests.size());
2043     RenameTagTemplateFieldEnumValueRequest actualRequest =
2044         ((RenameTagTemplateFieldEnumValueRequest) actualRequests.get(0));
2045 
2046     Assert.assertEquals(name.toString(), actualRequest.getName());
2047     Assert.assertEquals(newEnumValueDisplayName, actualRequest.getNewEnumValueDisplayName());
2048     Assert.assertTrue(
2049         channelProvider.isHeaderSent(
2050             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2051             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2052   }
2053 
2054   @Test
renameTagTemplateFieldEnumValueExceptionTest()2055   public void renameTagTemplateFieldEnumValueExceptionTest() throws Exception {
2056     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2057     mockDataCatalog.addException(exception);
2058 
2059     try {
2060       TagTemplateFieldEnumValueName name =
2061           TagTemplateFieldEnumValueName.of(
2062               "[PROJECT]",
2063               "[LOCATION]",
2064               "[TAG_TEMPLATE]",
2065               "[TAG_TEMPLATE_FIELD_ID]",
2066               "[ENUM_VALUE_DISPLAY_NAME]");
2067       String newEnumValueDisplayName = "newEnumValueDisplayName-1119629027";
2068       client.renameTagTemplateFieldEnumValue(name, newEnumValueDisplayName);
2069       Assert.fail("No exception raised");
2070     } catch (InvalidArgumentException e) {
2071       // Expected exception.
2072     }
2073   }
2074 
2075   @Test
renameTagTemplateFieldEnumValueTest2()2076   public void renameTagTemplateFieldEnumValueTest2() throws Exception {
2077     TagTemplateField expectedResponse =
2078         TagTemplateField.newBuilder()
2079             .setName(
2080                 TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]")
2081                     .toString())
2082             .setDisplayName("displayName1714148973")
2083             .setType(FieldType.newBuilder().build())
2084             .setIsRequired(true)
2085             .setDescription("description-1724546052")
2086             .setOrder(106006350)
2087             .build();
2088     mockDataCatalog.addResponse(expectedResponse);
2089 
2090     String name = "name3373707";
2091     String newEnumValueDisplayName = "newEnumValueDisplayName-1119629027";
2092 
2093     TagTemplateField actualResponse =
2094         client.renameTagTemplateFieldEnumValue(name, newEnumValueDisplayName);
2095     Assert.assertEquals(expectedResponse, actualResponse);
2096 
2097     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2098     Assert.assertEquals(1, actualRequests.size());
2099     RenameTagTemplateFieldEnumValueRequest actualRequest =
2100         ((RenameTagTemplateFieldEnumValueRequest) actualRequests.get(0));
2101 
2102     Assert.assertEquals(name, actualRequest.getName());
2103     Assert.assertEquals(newEnumValueDisplayName, actualRequest.getNewEnumValueDisplayName());
2104     Assert.assertTrue(
2105         channelProvider.isHeaderSent(
2106             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2107             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2108   }
2109 
2110   @Test
renameTagTemplateFieldEnumValueExceptionTest2()2111   public void renameTagTemplateFieldEnumValueExceptionTest2() throws Exception {
2112     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2113     mockDataCatalog.addException(exception);
2114 
2115     try {
2116       String name = "name3373707";
2117       String newEnumValueDisplayName = "newEnumValueDisplayName-1119629027";
2118       client.renameTagTemplateFieldEnumValue(name, newEnumValueDisplayName);
2119       Assert.fail("No exception raised");
2120     } catch (InvalidArgumentException e) {
2121       // Expected exception.
2122     }
2123   }
2124 
2125   @Test
deleteTagTemplateFieldTest()2126   public void deleteTagTemplateFieldTest() throws Exception {
2127     Empty expectedResponse = Empty.newBuilder().build();
2128     mockDataCatalog.addResponse(expectedResponse);
2129 
2130     TagTemplateFieldName name =
2131         TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
2132     boolean force = true;
2133 
2134     client.deleteTagTemplateField(name, force);
2135 
2136     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2137     Assert.assertEquals(1, actualRequests.size());
2138     DeleteTagTemplateFieldRequest actualRequest =
2139         ((DeleteTagTemplateFieldRequest) actualRequests.get(0));
2140 
2141     Assert.assertEquals(name.toString(), actualRequest.getName());
2142     Assert.assertEquals(force, actualRequest.getForce());
2143     Assert.assertTrue(
2144         channelProvider.isHeaderSent(
2145             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2146             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2147   }
2148 
2149   @Test
deleteTagTemplateFieldExceptionTest()2150   public void deleteTagTemplateFieldExceptionTest() throws Exception {
2151     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2152     mockDataCatalog.addException(exception);
2153 
2154     try {
2155       TagTemplateFieldName name =
2156           TagTemplateFieldName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]");
2157       boolean force = true;
2158       client.deleteTagTemplateField(name, force);
2159       Assert.fail("No exception raised");
2160     } catch (InvalidArgumentException e) {
2161       // Expected exception.
2162     }
2163   }
2164 
2165   @Test
deleteTagTemplateFieldTest2()2166   public void deleteTagTemplateFieldTest2() throws Exception {
2167     Empty expectedResponse = Empty.newBuilder().build();
2168     mockDataCatalog.addResponse(expectedResponse);
2169 
2170     String name = "name3373707";
2171     boolean force = true;
2172 
2173     client.deleteTagTemplateField(name, force);
2174 
2175     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2176     Assert.assertEquals(1, actualRequests.size());
2177     DeleteTagTemplateFieldRequest actualRequest =
2178         ((DeleteTagTemplateFieldRequest) actualRequests.get(0));
2179 
2180     Assert.assertEquals(name, actualRequest.getName());
2181     Assert.assertEquals(force, actualRequest.getForce());
2182     Assert.assertTrue(
2183         channelProvider.isHeaderSent(
2184             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2185             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2186   }
2187 
2188   @Test
deleteTagTemplateFieldExceptionTest2()2189   public void deleteTagTemplateFieldExceptionTest2() throws Exception {
2190     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2191     mockDataCatalog.addException(exception);
2192 
2193     try {
2194       String name = "name3373707";
2195       boolean force = true;
2196       client.deleteTagTemplateField(name, force);
2197       Assert.fail("No exception raised");
2198     } catch (InvalidArgumentException e) {
2199       // Expected exception.
2200     }
2201   }
2202 
2203   @Test
createTagTest()2204   public void createTagTest() throws Exception {
2205     Tag expectedResponse =
2206         Tag.newBuilder()
2207             .setName(
2208                 TagName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]", "[TAG]")
2209                     .toString())
2210             .setTemplate("template-1321546630")
2211             .setTemplateDisplayName("templateDisplayName713818515")
2212             .putAllFields(new HashMap<String, TagField>())
2213             .build();
2214     mockDataCatalog.addResponse(expectedResponse);
2215 
2216     EntryName parent = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2217     Tag tag = Tag.newBuilder().build();
2218 
2219     Tag actualResponse = client.createTag(parent, tag);
2220     Assert.assertEquals(expectedResponse, actualResponse);
2221 
2222     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2223     Assert.assertEquals(1, actualRequests.size());
2224     CreateTagRequest actualRequest = ((CreateTagRequest) actualRequests.get(0));
2225 
2226     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2227     Assert.assertEquals(tag, actualRequest.getTag());
2228     Assert.assertTrue(
2229         channelProvider.isHeaderSent(
2230             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2231             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2232   }
2233 
2234   @Test
createTagExceptionTest()2235   public void createTagExceptionTest() throws Exception {
2236     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2237     mockDataCatalog.addException(exception);
2238 
2239     try {
2240       EntryName parent = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2241       Tag tag = Tag.newBuilder().build();
2242       client.createTag(parent, tag);
2243       Assert.fail("No exception raised");
2244     } catch (InvalidArgumentException e) {
2245       // Expected exception.
2246     }
2247   }
2248 
2249   @Test
createTagTest2()2250   public void createTagTest2() throws Exception {
2251     Tag expectedResponse =
2252         Tag.newBuilder()
2253             .setName(
2254                 TagName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]", "[TAG]")
2255                     .toString())
2256             .setTemplate("template-1321546630")
2257             .setTemplateDisplayName("templateDisplayName713818515")
2258             .putAllFields(new HashMap<String, TagField>())
2259             .build();
2260     mockDataCatalog.addResponse(expectedResponse);
2261 
2262     String parent = "parent-995424086";
2263     Tag tag = Tag.newBuilder().build();
2264 
2265     Tag actualResponse = client.createTag(parent, tag);
2266     Assert.assertEquals(expectedResponse, actualResponse);
2267 
2268     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2269     Assert.assertEquals(1, actualRequests.size());
2270     CreateTagRequest actualRequest = ((CreateTagRequest) actualRequests.get(0));
2271 
2272     Assert.assertEquals(parent, actualRequest.getParent());
2273     Assert.assertEquals(tag, actualRequest.getTag());
2274     Assert.assertTrue(
2275         channelProvider.isHeaderSent(
2276             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2277             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2278   }
2279 
2280   @Test
createTagExceptionTest2()2281   public void createTagExceptionTest2() throws Exception {
2282     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2283     mockDataCatalog.addException(exception);
2284 
2285     try {
2286       String parent = "parent-995424086";
2287       Tag tag = Tag.newBuilder().build();
2288       client.createTag(parent, tag);
2289       Assert.fail("No exception raised");
2290     } catch (InvalidArgumentException e) {
2291       // Expected exception.
2292     }
2293   }
2294 
2295   @Test
updateTagTest()2296   public void updateTagTest() throws Exception {
2297     Tag expectedResponse =
2298         Tag.newBuilder()
2299             .setName(
2300                 TagName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]", "[TAG]")
2301                     .toString())
2302             .setTemplate("template-1321546630")
2303             .setTemplateDisplayName("templateDisplayName713818515")
2304             .putAllFields(new HashMap<String, TagField>())
2305             .build();
2306     mockDataCatalog.addResponse(expectedResponse);
2307 
2308     Tag tag = Tag.newBuilder().build();
2309 
2310     Tag actualResponse = client.updateTag(tag);
2311     Assert.assertEquals(expectedResponse, actualResponse);
2312 
2313     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2314     Assert.assertEquals(1, actualRequests.size());
2315     UpdateTagRequest actualRequest = ((UpdateTagRequest) actualRequests.get(0));
2316 
2317     Assert.assertEquals(tag, actualRequest.getTag());
2318     Assert.assertTrue(
2319         channelProvider.isHeaderSent(
2320             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2321             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2322   }
2323 
2324   @Test
updateTagExceptionTest()2325   public void updateTagExceptionTest() throws Exception {
2326     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2327     mockDataCatalog.addException(exception);
2328 
2329     try {
2330       Tag tag = Tag.newBuilder().build();
2331       client.updateTag(tag);
2332       Assert.fail("No exception raised");
2333     } catch (InvalidArgumentException e) {
2334       // Expected exception.
2335     }
2336   }
2337 
2338   @Test
updateTagTest2()2339   public void updateTagTest2() throws Exception {
2340     Tag expectedResponse =
2341         Tag.newBuilder()
2342             .setName(
2343                 TagName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]", "[TAG]")
2344                     .toString())
2345             .setTemplate("template-1321546630")
2346             .setTemplateDisplayName("templateDisplayName713818515")
2347             .putAllFields(new HashMap<String, TagField>())
2348             .build();
2349     mockDataCatalog.addResponse(expectedResponse);
2350 
2351     Tag tag = Tag.newBuilder().build();
2352     FieldMask updateMask = FieldMask.newBuilder().build();
2353 
2354     Tag actualResponse = client.updateTag(tag, updateMask);
2355     Assert.assertEquals(expectedResponse, actualResponse);
2356 
2357     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2358     Assert.assertEquals(1, actualRequests.size());
2359     UpdateTagRequest actualRequest = ((UpdateTagRequest) actualRequests.get(0));
2360 
2361     Assert.assertEquals(tag, actualRequest.getTag());
2362     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
2363     Assert.assertTrue(
2364         channelProvider.isHeaderSent(
2365             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2366             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2367   }
2368 
2369   @Test
updateTagExceptionTest2()2370   public void updateTagExceptionTest2() throws Exception {
2371     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2372     mockDataCatalog.addException(exception);
2373 
2374     try {
2375       Tag tag = Tag.newBuilder().build();
2376       FieldMask updateMask = FieldMask.newBuilder().build();
2377       client.updateTag(tag, updateMask);
2378       Assert.fail("No exception raised");
2379     } catch (InvalidArgumentException e) {
2380       // Expected exception.
2381     }
2382   }
2383 
2384   @Test
deleteTagTest()2385   public void deleteTagTest() throws Exception {
2386     Empty expectedResponse = Empty.newBuilder().build();
2387     mockDataCatalog.addResponse(expectedResponse);
2388 
2389     EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2390 
2391     client.deleteTag(name);
2392 
2393     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2394     Assert.assertEquals(1, actualRequests.size());
2395     DeleteTagRequest actualRequest = ((DeleteTagRequest) actualRequests.get(0));
2396 
2397     Assert.assertEquals(name.toString(), actualRequest.getName());
2398     Assert.assertTrue(
2399         channelProvider.isHeaderSent(
2400             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2401             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2402   }
2403 
2404   @Test
deleteTagExceptionTest()2405   public void deleteTagExceptionTest() throws Exception {
2406     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2407     mockDataCatalog.addException(exception);
2408 
2409     try {
2410       EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2411       client.deleteTag(name);
2412       Assert.fail("No exception raised");
2413     } catch (InvalidArgumentException e) {
2414       // Expected exception.
2415     }
2416   }
2417 
2418   @Test
deleteTagTest2()2419   public void deleteTagTest2() throws Exception {
2420     Empty expectedResponse = Empty.newBuilder().build();
2421     mockDataCatalog.addResponse(expectedResponse);
2422 
2423     String name = "name3373707";
2424 
2425     client.deleteTag(name);
2426 
2427     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2428     Assert.assertEquals(1, actualRequests.size());
2429     DeleteTagRequest actualRequest = ((DeleteTagRequest) actualRequests.get(0));
2430 
2431     Assert.assertEquals(name, actualRequest.getName());
2432     Assert.assertTrue(
2433         channelProvider.isHeaderSent(
2434             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2435             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2436   }
2437 
2438   @Test
deleteTagExceptionTest2()2439   public void deleteTagExceptionTest2() throws Exception {
2440     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2441     mockDataCatalog.addException(exception);
2442 
2443     try {
2444       String name = "name3373707";
2445       client.deleteTag(name);
2446       Assert.fail("No exception raised");
2447     } catch (InvalidArgumentException e) {
2448       // Expected exception.
2449     }
2450   }
2451 
2452   @Test
listTagsTest()2453   public void listTagsTest() throws Exception {
2454     Tag responsesElement = Tag.newBuilder().build();
2455     ListTagsResponse expectedResponse =
2456         ListTagsResponse.newBuilder()
2457             .setNextPageToken("")
2458             .addAllTags(Arrays.asList(responsesElement))
2459             .build();
2460     mockDataCatalog.addResponse(expectedResponse);
2461 
2462     EntryName parent = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2463 
2464     ListTagsPagedResponse pagedListResponse = client.listTags(parent);
2465 
2466     List<Tag> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2467 
2468     Assert.assertEquals(1, resources.size());
2469     Assert.assertEquals(expectedResponse.getTagsList().get(0), resources.get(0));
2470 
2471     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2472     Assert.assertEquals(1, actualRequests.size());
2473     ListTagsRequest actualRequest = ((ListTagsRequest) actualRequests.get(0));
2474 
2475     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2476     Assert.assertTrue(
2477         channelProvider.isHeaderSent(
2478             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2479             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2480   }
2481 
2482   @Test
listTagsExceptionTest()2483   public void listTagsExceptionTest() throws Exception {
2484     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2485     mockDataCatalog.addException(exception);
2486 
2487     try {
2488       EntryName parent = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2489       client.listTags(parent);
2490       Assert.fail("No exception raised");
2491     } catch (InvalidArgumentException e) {
2492       // Expected exception.
2493     }
2494   }
2495 
2496   @Test
listTagsTest2()2497   public void listTagsTest2() throws Exception {
2498     Tag responsesElement = Tag.newBuilder().build();
2499     ListTagsResponse expectedResponse =
2500         ListTagsResponse.newBuilder()
2501             .setNextPageToken("")
2502             .addAllTags(Arrays.asList(responsesElement))
2503             .build();
2504     mockDataCatalog.addResponse(expectedResponse);
2505 
2506     String parent = "parent-995424086";
2507 
2508     ListTagsPagedResponse pagedListResponse = client.listTags(parent);
2509 
2510     List<Tag> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2511 
2512     Assert.assertEquals(1, resources.size());
2513     Assert.assertEquals(expectedResponse.getTagsList().get(0), resources.get(0));
2514 
2515     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2516     Assert.assertEquals(1, actualRequests.size());
2517     ListTagsRequest actualRequest = ((ListTagsRequest) actualRequests.get(0));
2518 
2519     Assert.assertEquals(parent, actualRequest.getParent());
2520     Assert.assertTrue(
2521         channelProvider.isHeaderSent(
2522             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2523             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2524   }
2525 
2526   @Test
listTagsExceptionTest2()2527   public void listTagsExceptionTest2() throws Exception {
2528     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2529     mockDataCatalog.addException(exception);
2530 
2531     try {
2532       String parent = "parent-995424086";
2533       client.listTags(parent);
2534       Assert.fail("No exception raised");
2535     } catch (InvalidArgumentException e) {
2536       // Expected exception.
2537     }
2538   }
2539 
2540   @Test
reconcileTagsTest()2541   public void reconcileTagsTest() throws Exception {
2542     ReconcileTagsResponse expectedResponse =
2543         ReconcileTagsResponse.newBuilder()
2544             .setCreatedTagsCount(-986601696)
2545             .setUpdatedTagsCount(344847213)
2546             .setDeletedTagsCount(59637071)
2547             .build();
2548     Operation resultOperation =
2549         Operation.newBuilder()
2550             .setName("reconcileTagsTest")
2551             .setDone(true)
2552             .setResponse(Any.pack(expectedResponse))
2553             .build();
2554     mockDataCatalog.addResponse(resultOperation);
2555 
2556     ReconcileTagsRequest request =
2557         ReconcileTagsRequest.newBuilder()
2558             .setParent(
2559                 EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
2560             .setTagTemplate(
2561                 TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
2562             .setForceDeleteMissing(true)
2563             .addAllTags(new ArrayList<Tag>())
2564             .build();
2565 
2566     ReconcileTagsResponse actualResponse = client.reconcileTagsAsync(request).get();
2567     Assert.assertEquals(expectedResponse, actualResponse);
2568 
2569     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2570     Assert.assertEquals(1, actualRequests.size());
2571     ReconcileTagsRequest actualRequest = ((ReconcileTagsRequest) actualRequests.get(0));
2572 
2573     Assert.assertEquals(request.getParent(), actualRequest.getParent());
2574     Assert.assertEquals(request.getTagTemplate(), actualRequest.getTagTemplate());
2575     Assert.assertEquals(request.getForceDeleteMissing(), actualRequest.getForceDeleteMissing());
2576     Assert.assertEquals(request.getTagsList(), actualRequest.getTagsList());
2577     Assert.assertTrue(
2578         channelProvider.isHeaderSent(
2579             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2580             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2581   }
2582 
2583   @Test
reconcileTagsExceptionTest()2584   public void reconcileTagsExceptionTest() throws Exception {
2585     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2586     mockDataCatalog.addException(exception);
2587 
2588     try {
2589       ReconcileTagsRequest request =
2590           ReconcileTagsRequest.newBuilder()
2591               .setParent(
2592                   EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
2593               .setTagTemplate(
2594                   TagTemplateName.of("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]").toString())
2595               .setForceDeleteMissing(true)
2596               .addAllTags(new ArrayList<Tag>())
2597               .build();
2598       client.reconcileTagsAsync(request).get();
2599       Assert.fail("No exception raised");
2600     } catch (ExecutionException e) {
2601       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2602       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2603       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2604     }
2605   }
2606 
2607   @Test
starEntryTest()2608   public void starEntryTest() throws Exception {
2609     StarEntryResponse expectedResponse = StarEntryResponse.newBuilder().build();
2610     mockDataCatalog.addResponse(expectedResponse);
2611 
2612     EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2613 
2614     StarEntryResponse actualResponse = client.starEntry(name);
2615     Assert.assertEquals(expectedResponse, actualResponse);
2616 
2617     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2618     Assert.assertEquals(1, actualRequests.size());
2619     StarEntryRequest actualRequest = ((StarEntryRequest) actualRequests.get(0));
2620 
2621     Assert.assertEquals(name.toString(), actualRequest.getName());
2622     Assert.assertTrue(
2623         channelProvider.isHeaderSent(
2624             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2625             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2626   }
2627 
2628   @Test
starEntryExceptionTest()2629   public void starEntryExceptionTest() throws Exception {
2630     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2631     mockDataCatalog.addException(exception);
2632 
2633     try {
2634       EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2635       client.starEntry(name);
2636       Assert.fail("No exception raised");
2637     } catch (InvalidArgumentException e) {
2638       // Expected exception.
2639     }
2640   }
2641 
2642   @Test
starEntryTest2()2643   public void starEntryTest2() throws Exception {
2644     StarEntryResponse expectedResponse = StarEntryResponse.newBuilder().build();
2645     mockDataCatalog.addResponse(expectedResponse);
2646 
2647     String name = "name3373707";
2648 
2649     StarEntryResponse actualResponse = client.starEntry(name);
2650     Assert.assertEquals(expectedResponse, actualResponse);
2651 
2652     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2653     Assert.assertEquals(1, actualRequests.size());
2654     StarEntryRequest actualRequest = ((StarEntryRequest) actualRequests.get(0));
2655 
2656     Assert.assertEquals(name, actualRequest.getName());
2657     Assert.assertTrue(
2658         channelProvider.isHeaderSent(
2659             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2660             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2661   }
2662 
2663   @Test
starEntryExceptionTest2()2664   public void starEntryExceptionTest2() throws Exception {
2665     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2666     mockDataCatalog.addException(exception);
2667 
2668     try {
2669       String name = "name3373707";
2670       client.starEntry(name);
2671       Assert.fail("No exception raised");
2672     } catch (InvalidArgumentException e) {
2673       // Expected exception.
2674     }
2675   }
2676 
2677   @Test
unstarEntryTest()2678   public void unstarEntryTest() throws Exception {
2679     UnstarEntryResponse expectedResponse = UnstarEntryResponse.newBuilder().build();
2680     mockDataCatalog.addResponse(expectedResponse);
2681 
2682     EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2683 
2684     UnstarEntryResponse actualResponse = client.unstarEntry(name);
2685     Assert.assertEquals(expectedResponse, actualResponse);
2686 
2687     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2688     Assert.assertEquals(1, actualRequests.size());
2689     UnstarEntryRequest actualRequest = ((UnstarEntryRequest) actualRequests.get(0));
2690 
2691     Assert.assertEquals(name.toString(), actualRequest.getName());
2692     Assert.assertTrue(
2693         channelProvider.isHeaderSent(
2694             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2695             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2696   }
2697 
2698   @Test
unstarEntryExceptionTest()2699   public void unstarEntryExceptionTest() throws Exception {
2700     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2701     mockDataCatalog.addException(exception);
2702 
2703     try {
2704       EntryName name = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2705       client.unstarEntry(name);
2706       Assert.fail("No exception raised");
2707     } catch (InvalidArgumentException e) {
2708       // Expected exception.
2709     }
2710   }
2711 
2712   @Test
unstarEntryTest2()2713   public void unstarEntryTest2() throws Exception {
2714     UnstarEntryResponse expectedResponse = UnstarEntryResponse.newBuilder().build();
2715     mockDataCatalog.addResponse(expectedResponse);
2716 
2717     String name = "name3373707";
2718 
2719     UnstarEntryResponse actualResponse = client.unstarEntry(name);
2720     Assert.assertEquals(expectedResponse, actualResponse);
2721 
2722     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2723     Assert.assertEquals(1, actualRequests.size());
2724     UnstarEntryRequest actualRequest = ((UnstarEntryRequest) actualRequests.get(0));
2725 
2726     Assert.assertEquals(name, actualRequest.getName());
2727     Assert.assertTrue(
2728         channelProvider.isHeaderSent(
2729             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2730             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2731   }
2732 
2733   @Test
unstarEntryExceptionTest2()2734   public void unstarEntryExceptionTest2() throws Exception {
2735     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2736     mockDataCatalog.addException(exception);
2737 
2738     try {
2739       String name = "name3373707";
2740       client.unstarEntry(name);
2741       Assert.fail("No exception raised");
2742     } catch (InvalidArgumentException e) {
2743       // Expected exception.
2744     }
2745   }
2746 
2747   @Test
setIamPolicyTest()2748   public void setIamPolicyTest() throws Exception {
2749     Policy expectedResponse =
2750         Policy.newBuilder()
2751             .setVersion(351608024)
2752             .addAllBindings(new ArrayList<Binding>())
2753             .addAllAuditConfigs(new ArrayList<AuditConfig>())
2754             .setEtag(ByteString.EMPTY)
2755             .build();
2756     mockDataCatalog.addResponse(expectedResponse);
2757 
2758     ResourceName resource = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
2759     Policy policy = Policy.newBuilder().build();
2760 
2761     Policy actualResponse = client.setIamPolicy(resource, policy);
2762     Assert.assertEquals(expectedResponse, actualResponse);
2763 
2764     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2765     Assert.assertEquals(1, actualRequests.size());
2766     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
2767 
2768     Assert.assertEquals(resource.toString(), actualRequest.getResource());
2769     Assert.assertEquals(policy, actualRequest.getPolicy());
2770     Assert.assertTrue(
2771         channelProvider.isHeaderSent(
2772             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2773             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2774   }
2775 
2776   @Test
setIamPolicyExceptionTest()2777   public void setIamPolicyExceptionTest() throws Exception {
2778     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2779     mockDataCatalog.addException(exception);
2780 
2781     try {
2782       ResourceName resource = EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
2783       Policy policy = Policy.newBuilder().build();
2784       client.setIamPolicy(resource, policy);
2785       Assert.fail("No exception raised");
2786     } catch (InvalidArgumentException e) {
2787       // Expected exception.
2788     }
2789   }
2790 
2791   @Test
setIamPolicyTest2()2792   public void setIamPolicyTest2() throws Exception {
2793     Policy expectedResponse =
2794         Policy.newBuilder()
2795             .setVersion(351608024)
2796             .addAllBindings(new ArrayList<Binding>())
2797             .addAllAuditConfigs(new ArrayList<AuditConfig>())
2798             .setEtag(ByteString.EMPTY)
2799             .build();
2800     mockDataCatalog.addResponse(expectedResponse);
2801 
2802     String resource = "resource-341064690";
2803     Policy policy = Policy.newBuilder().build();
2804 
2805     Policy actualResponse = client.setIamPolicy(resource, policy);
2806     Assert.assertEquals(expectedResponse, actualResponse);
2807 
2808     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2809     Assert.assertEquals(1, actualRequests.size());
2810     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
2811 
2812     Assert.assertEquals(resource, actualRequest.getResource());
2813     Assert.assertEquals(policy, actualRequest.getPolicy());
2814     Assert.assertTrue(
2815         channelProvider.isHeaderSent(
2816             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2817             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2818   }
2819 
2820   @Test
setIamPolicyExceptionTest2()2821   public void setIamPolicyExceptionTest2() throws Exception {
2822     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2823     mockDataCatalog.addException(exception);
2824 
2825     try {
2826       String resource = "resource-341064690";
2827       Policy policy = Policy.newBuilder().build();
2828       client.setIamPolicy(resource, policy);
2829       Assert.fail("No exception raised");
2830     } catch (InvalidArgumentException e) {
2831       // Expected exception.
2832     }
2833   }
2834 
2835   @Test
getIamPolicyTest()2836   public void getIamPolicyTest() throws Exception {
2837     Policy expectedResponse =
2838         Policy.newBuilder()
2839             .setVersion(351608024)
2840             .addAllBindings(new ArrayList<Binding>())
2841             .addAllAuditConfigs(new ArrayList<AuditConfig>())
2842             .setEtag(ByteString.EMPTY)
2843             .build();
2844     mockDataCatalog.addResponse(expectedResponse);
2845 
2846     ResourceName resource = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2847 
2848     Policy actualResponse = client.getIamPolicy(resource);
2849     Assert.assertEquals(expectedResponse, actualResponse);
2850 
2851     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2852     Assert.assertEquals(1, actualRequests.size());
2853     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
2854 
2855     Assert.assertEquals(resource.toString(), actualRequest.getResource());
2856     Assert.assertTrue(
2857         channelProvider.isHeaderSent(
2858             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2859             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2860   }
2861 
2862   @Test
getIamPolicyExceptionTest()2863   public void getIamPolicyExceptionTest() throws Exception {
2864     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2865     mockDataCatalog.addException(exception);
2866 
2867     try {
2868       ResourceName resource = EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
2869       client.getIamPolicy(resource);
2870       Assert.fail("No exception raised");
2871     } catch (InvalidArgumentException e) {
2872       // Expected exception.
2873     }
2874   }
2875 
2876   @Test
getIamPolicyTest2()2877   public void getIamPolicyTest2() throws Exception {
2878     Policy expectedResponse =
2879         Policy.newBuilder()
2880             .setVersion(351608024)
2881             .addAllBindings(new ArrayList<Binding>())
2882             .addAllAuditConfigs(new ArrayList<AuditConfig>())
2883             .setEtag(ByteString.EMPTY)
2884             .build();
2885     mockDataCatalog.addResponse(expectedResponse);
2886 
2887     String resource = "resource-341064690";
2888 
2889     Policy actualResponse = client.getIamPolicy(resource);
2890     Assert.assertEquals(expectedResponse, actualResponse);
2891 
2892     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2893     Assert.assertEquals(1, actualRequests.size());
2894     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
2895 
2896     Assert.assertEquals(resource, actualRequest.getResource());
2897     Assert.assertTrue(
2898         channelProvider.isHeaderSent(
2899             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2900             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2901   }
2902 
2903   @Test
getIamPolicyExceptionTest2()2904   public void getIamPolicyExceptionTest2() throws Exception {
2905     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2906     mockDataCatalog.addException(exception);
2907 
2908     try {
2909       String resource = "resource-341064690";
2910       client.getIamPolicy(resource);
2911       Assert.fail("No exception raised");
2912     } catch (InvalidArgumentException e) {
2913       // Expected exception.
2914     }
2915   }
2916 
2917   @Test
testIamPermissionsTest()2918   public void testIamPermissionsTest() throws Exception {
2919     TestIamPermissionsResponse expectedResponse =
2920         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
2921     mockDataCatalog.addResponse(expectedResponse);
2922 
2923     TestIamPermissionsRequest request =
2924         TestIamPermissionsRequest.newBuilder()
2925             .setResource(
2926                 EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
2927             .addAllPermissions(new ArrayList<String>())
2928             .build();
2929 
2930     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
2931     Assert.assertEquals(expectedResponse, actualResponse);
2932 
2933     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2934     Assert.assertEquals(1, actualRequests.size());
2935     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
2936 
2937     Assert.assertEquals(request.getResource(), actualRequest.getResource());
2938     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
2939     Assert.assertTrue(
2940         channelProvider.isHeaderSent(
2941             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2942             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2943   }
2944 
2945   @Test
testIamPermissionsExceptionTest()2946   public void testIamPermissionsExceptionTest() throws Exception {
2947     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2948     mockDataCatalog.addException(exception);
2949 
2950     try {
2951       TestIamPermissionsRequest request =
2952           TestIamPermissionsRequest.newBuilder()
2953               .setResource(
2954                   EntryName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]").toString())
2955               .addAllPermissions(new ArrayList<String>())
2956               .build();
2957       client.testIamPermissions(request);
2958       Assert.fail("No exception raised");
2959     } catch (InvalidArgumentException e) {
2960       // Expected exception.
2961     }
2962   }
2963 
2964   @Test
importEntriesTest()2965   public void importEntriesTest() throws Exception {
2966     ImportEntriesResponse expectedResponse =
2967         ImportEntriesResponse.newBuilder()
2968             .setUpsertedEntriesCount(250168367)
2969             .setDeletedEntriesCount(-167383302)
2970             .build();
2971     Operation resultOperation =
2972         Operation.newBuilder()
2973             .setName("importEntriesTest")
2974             .setDone(true)
2975             .setResponse(Any.pack(expectedResponse))
2976             .build();
2977     mockDataCatalog.addResponse(resultOperation);
2978 
2979     ImportEntriesRequest request =
2980         ImportEntriesRequest.newBuilder()
2981             .setParent(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
2982             .build();
2983 
2984     ImportEntriesResponse actualResponse = client.importEntriesAsync(request).get();
2985     Assert.assertEquals(expectedResponse, actualResponse);
2986 
2987     List<AbstractMessage> actualRequests = mockDataCatalog.getRequests();
2988     Assert.assertEquals(1, actualRequests.size());
2989     ImportEntriesRequest actualRequest = ((ImportEntriesRequest) actualRequests.get(0));
2990 
2991     Assert.assertEquals(request.getParent(), actualRequest.getParent());
2992     Assert.assertEquals(request.getGcsBucketPath(), actualRequest.getGcsBucketPath());
2993     Assert.assertTrue(
2994         channelProvider.isHeaderSent(
2995             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2996             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2997   }
2998 
2999   @Test
importEntriesExceptionTest()3000   public void importEntriesExceptionTest() throws Exception {
3001     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3002     mockDataCatalog.addException(exception);
3003 
3004     try {
3005       ImportEntriesRequest request =
3006           ImportEntriesRequest.newBuilder()
3007               .setParent(EntryGroupName.of("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]").toString())
3008               .build();
3009       client.importEntriesAsync(request).get();
3010       Assert.fail("No exception raised");
3011     } catch (ExecutionException e) {
3012       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
3013       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
3014       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
3015     }
3016   }
3017 }
3018