• 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.dlp.v2;
18 
19 import static com.google.cloud.dlp.v2.DlpServiceClient.ListDeidentifyTemplatesPagedResponse;
20 import static com.google.cloud.dlp.v2.DlpServiceClient.ListDlpJobsPagedResponse;
21 import static com.google.cloud.dlp.v2.DlpServiceClient.ListInspectTemplatesPagedResponse;
22 import static com.google.cloud.dlp.v2.DlpServiceClient.ListJobTriggersPagedResponse;
23 import static com.google.cloud.dlp.v2.DlpServiceClient.ListStoredInfoTypesPagedResponse;
24 
25 import com.google.api.gax.core.NoCredentialsProvider;
26 import com.google.api.gax.grpc.GaxGrpcProperties;
27 import com.google.api.gax.grpc.testing.LocalChannelProvider;
28 import com.google.api.gax.grpc.testing.MockGrpcService;
29 import com.google.api.gax.grpc.testing.MockServiceHelper;
30 import com.google.api.gax.rpc.ApiClientHeaderProvider;
31 import com.google.api.gax.rpc.InvalidArgumentException;
32 import com.google.common.collect.Lists;
33 import com.google.privacy.dlp.v2.ActivateJobTriggerRequest;
34 import com.google.privacy.dlp.v2.ByteContentItem;
35 import com.google.privacy.dlp.v2.CancelDlpJobRequest;
36 import com.google.privacy.dlp.v2.ContentItem;
37 import com.google.privacy.dlp.v2.CreateDeidentifyTemplateRequest;
38 import com.google.privacy.dlp.v2.CreateDlpJobRequest;
39 import com.google.privacy.dlp.v2.CreateInspectTemplateRequest;
40 import com.google.privacy.dlp.v2.CreateJobTriggerRequest;
41 import com.google.privacy.dlp.v2.CreateStoredInfoTypeRequest;
42 import com.google.privacy.dlp.v2.DeidentifyConfig;
43 import com.google.privacy.dlp.v2.DeidentifyContentRequest;
44 import com.google.privacy.dlp.v2.DeidentifyContentResponse;
45 import com.google.privacy.dlp.v2.DeidentifyTemplate;
46 import com.google.privacy.dlp.v2.DeidentifyTemplateName;
47 import com.google.privacy.dlp.v2.DeleteDeidentifyTemplateRequest;
48 import com.google.privacy.dlp.v2.DeleteDlpJobRequest;
49 import com.google.privacy.dlp.v2.DeleteInspectTemplateRequest;
50 import com.google.privacy.dlp.v2.DeleteJobTriggerRequest;
51 import com.google.privacy.dlp.v2.DeleteStoredInfoTypeRequest;
52 import com.google.privacy.dlp.v2.DlpJob;
53 import com.google.privacy.dlp.v2.DlpJobName;
54 import com.google.privacy.dlp.v2.DlpJobType;
55 import com.google.privacy.dlp.v2.Error;
56 import com.google.privacy.dlp.v2.FinishDlpJobRequest;
57 import com.google.privacy.dlp.v2.GetDeidentifyTemplateRequest;
58 import com.google.privacy.dlp.v2.GetDlpJobRequest;
59 import com.google.privacy.dlp.v2.GetInspectTemplateRequest;
60 import com.google.privacy.dlp.v2.GetJobTriggerRequest;
61 import com.google.privacy.dlp.v2.GetStoredInfoTypeRequest;
62 import com.google.privacy.dlp.v2.HybridInspectDlpJobRequest;
63 import com.google.privacy.dlp.v2.HybridInspectJobTriggerRequest;
64 import com.google.privacy.dlp.v2.HybridInspectResponse;
65 import com.google.privacy.dlp.v2.InfoTypeDescription;
66 import com.google.privacy.dlp.v2.InspectConfig;
67 import com.google.privacy.dlp.v2.InspectContentRequest;
68 import com.google.privacy.dlp.v2.InspectContentResponse;
69 import com.google.privacy.dlp.v2.InspectJobConfig;
70 import com.google.privacy.dlp.v2.InspectResult;
71 import com.google.privacy.dlp.v2.InspectTemplate;
72 import com.google.privacy.dlp.v2.InspectTemplateName;
73 import com.google.privacy.dlp.v2.JobTrigger;
74 import com.google.privacy.dlp.v2.JobTriggerName;
75 import com.google.privacy.dlp.v2.ListDeidentifyTemplatesRequest;
76 import com.google.privacy.dlp.v2.ListDeidentifyTemplatesResponse;
77 import com.google.privacy.dlp.v2.ListDlpJobsRequest;
78 import com.google.privacy.dlp.v2.ListDlpJobsResponse;
79 import com.google.privacy.dlp.v2.ListInfoTypesRequest;
80 import com.google.privacy.dlp.v2.ListInfoTypesResponse;
81 import com.google.privacy.dlp.v2.ListInspectTemplatesRequest;
82 import com.google.privacy.dlp.v2.ListInspectTemplatesResponse;
83 import com.google.privacy.dlp.v2.ListJobTriggersRequest;
84 import com.google.privacy.dlp.v2.ListJobTriggersResponse;
85 import com.google.privacy.dlp.v2.ListStoredInfoTypesRequest;
86 import com.google.privacy.dlp.v2.ListStoredInfoTypesResponse;
87 import com.google.privacy.dlp.v2.LocationName;
88 import com.google.privacy.dlp.v2.OrganizationLocationName;
89 import com.google.privacy.dlp.v2.OrganizationName;
90 import com.google.privacy.dlp.v2.ProjectName;
91 import com.google.privacy.dlp.v2.RedactImageRequest;
92 import com.google.privacy.dlp.v2.RedactImageResponse;
93 import com.google.privacy.dlp.v2.ReidentifyContentRequest;
94 import com.google.privacy.dlp.v2.ReidentifyContentResponse;
95 import com.google.privacy.dlp.v2.RiskAnalysisJobConfig;
96 import com.google.privacy.dlp.v2.StoredInfoType;
97 import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
98 import com.google.privacy.dlp.v2.StoredInfoTypeName;
99 import com.google.privacy.dlp.v2.StoredInfoTypeVersion;
100 import com.google.privacy.dlp.v2.TransformationOverview;
101 import com.google.privacy.dlp.v2.UpdateDeidentifyTemplateRequest;
102 import com.google.privacy.dlp.v2.UpdateInspectTemplateRequest;
103 import com.google.privacy.dlp.v2.UpdateJobTriggerRequest;
104 import com.google.privacy.dlp.v2.UpdateStoredInfoTypeRequest;
105 import com.google.protobuf.AbstractMessage;
106 import com.google.protobuf.ByteString;
107 import com.google.protobuf.Empty;
108 import com.google.protobuf.FieldMask;
109 import com.google.protobuf.Timestamp;
110 import io.grpc.StatusRuntimeException;
111 import java.io.IOException;
112 import java.util.ArrayList;
113 import java.util.Arrays;
114 import java.util.List;
115 import java.util.UUID;
116 import javax.annotation.Generated;
117 import org.junit.After;
118 import org.junit.AfterClass;
119 import org.junit.Assert;
120 import org.junit.Before;
121 import org.junit.BeforeClass;
122 import org.junit.Test;
123 
124 @Generated("by gapic-generator-java")
125 public class DlpServiceClientTest {
126   private static MockDlpService mockDlpService;
127   private static MockServiceHelper mockServiceHelper;
128   private LocalChannelProvider channelProvider;
129   private DlpServiceClient client;
130 
131   @BeforeClass
startStaticServer()132   public static void startStaticServer() {
133     mockDlpService = new MockDlpService();
134     mockServiceHelper =
135         new MockServiceHelper(
136             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockDlpService));
137     mockServiceHelper.start();
138   }
139 
140   @AfterClass
stopServer()141   public static void stopServer() {
142     mockServiceHelper.stop();
143   }
144 
145   @Before
setUp()146   public void setUp() throws IOException {
147     mockServiceHelper.reset();
148     channelProvider = mockServiceHelper.createChannelProvider();
149     DlpServiceSettings settings =
150         DlpServiceSettings.newBuilder()
151             .setTransportChannelProvider(channelProvider)
152             .setCredentialsProvider(NoCredentialsProvider.create())
153             .build();
154     client = DlpServiceClient.create(settings);
155   }
156 
157   @After
tearDown()158   public void tearDown() throws Exception {
159     client.close();
160   }
161 
162   @Test
inspectContentTest()163   public void inspectContentTest() throws Exception {
164     InspectContentResponse expectedResponse =
165         InspectContentResponse.newBuilder().setResult(InspectResult.newBuilder().build()).build();
166     mockDlpService.addResponse(expectedResponse);
167 
168     InspectContentRequest request =
169         InspectContentRequest.newBuilder()
170             .setParent(ProjectName.of("[PROJECT]").toString())
171             .setInspectConfig(InspectConfig.newBuilder().build())
172             .setItem(ContentItem.newBuilder().build())
173             .setInspectTemplateName("inspectTemplateName1828857433")
174             .setLocationId("locationId1541836720")
175             .build();
176 
177     InspectContentResponse actualResponse = client.inspectContent(request);
178     Assert.assertEquals(expectedResponse, actualResponse);
179 
180     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
181     Assert.assertEquals(1, actualRequests.size());
182     InspectContentRequest actualRequest = ((InspectContentRequest) actualRequests.get(0));
183 
184     Assert.assertEquals(request.getParent(), actualRequest.getParent());
185     Assert.assertEquals(request.getInspectConfig(), actualRequest.getInspectConfig());
186     Assert.assertEquals(request.getItem(), actualRequest.getItem());
187     Assert.assertEquals(request.getInspectTemplateName(), actualRequest.getInspectTemplateName());
188     Assert.assertEquals(request.getLocationId(), actualRequest.getLocationId());
189     Assert.assertTrue(
190         channelProvider.isHeaderSent(
191             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
192             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
193   }
194 
195   @Test
inspectContentExceptionTest()196   public void inspectContentExceptionTest() throws Exception {
197     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
198     mockDlpService.addException(exception);
199 
200     try {
201       InspectContentRequest request =
202           InspectContentRequest.newBuilder()
203               .setParent(ProjectName.of("[PROJECT]").toString())
204               .setInspectConfig(InspectConfig.newBuilder().build())
205               .setItem(ContentItem.newBuilder().build())
206               .setInspectTemplateName("inspectTemplateName1828857433")
207               .setLocationId("locationId1541836720")
208               .build();
209       client.inspectContent(request);
210       Assert.fail("No exception raised");
211     } catch (InvalidArgumentException e) {
212       // Expected exception.
213     }
214   }
215 
216   @Test
redactImageTest()217   public void redactImageTest() throws Exception {
218     RedactImageResponse expectedResponse =
219         RedactImageResponse.newBuilder()
220             .setRedactedImage(ByteString.EMPTY)
221             .setExtractedText("extractedText-106686931")
222             .setInspectResult(InspectResult.newBuilder().build())
223             .build();
224     mockDlpService.addResponse(expectedResponse);
225 
226     RedactImageRequest request =
227         RedactImageRequest.newBuilder()
228             .setParent(ProjectName.of("[PROJECT]").toString())
229             .setLocationId("locationId1541836720")
230             .setInspectConfig(InspectConfig.newBuilder().build())
231             .addAllImageRedactionConfigs(new ArrayList<RedactImageRequest.ImageRedactionConfig>())
232             .setIncludeFindings(true)
233             .setByteItem(ByteContentItem.newBuilder().build())
234             .build();
235 
236     RedactImageResponse actualResponse = client.redactImage(request);
237     Assert.assertEquals(expectedResponse, actualResponse);
238 
239     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
240     Assert.assertEquals(1, actualRequests.size());
241     RedactImageRequest actualRequest = ((RedactImageRequest) actualRequests.get(0));
242 
243     Assert.assertEquals(request.getParent(), actualRequest.getParent());
244     Assert.assertEquals(request.getLocationId(), actualRequest.getLocationId());
245     Assert.assertEquals(request.getInspectConfig(), actualRequest.getInspectConfig());
246     Assert.assertEquals(
247         request.getImageRedactionConfigsList(), actualRequest.getImageRedactionConfigsList());
248     Assert.assertEquals(request.getIncludeFindings(), actualRequest.getIncludeFindings());
249     Assert.assertEquals(request.getByteItem(), actualRequest.getByteItem());
250     Assert.assertTrue(
251         channelProvider.isHeaderSent(
252             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
253             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
254   }
255 
256   @Test
redactImageExceptionTest()257   public void redactImageExceptionTest() throws Exception {
258     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
259     mockDlpService.addException(exception);
260 
261     try {
262       RedactImageRequest request =
263           RedactImageRequest.newBuilder()
264               .setParent(ProjectName.of("[PROJECT]").toString())
265               .setLocationId("locationId1541836720")
266               .setInspectConfig(InspectConfig.newBuilder().build())
267               .addAllImageRedactionConfigs(new ArrayList<RedactImageRequest.ImageRedactionConfig>())
268               .setIncludeFindings(true)
269               .setByteItem(ByteContentItem.newBuilder().build())
270               .build();
271       client.redactImage(request);
272       Assert.fail("No exception raised");
273     } catch (InvalidArgumentException e) {
274       // Expected exception.
275     }
276   }
277 
278   @Test
deidentifyContentTest()279   public void deidentifyContentTest() throws Exception {
280     DeidentifyContentResponse expectedResponse =
281         DeidentifyContentResponse.newBuilder()
282             .setItem(ContentItem.newBuilder().build())
283             .setOverview(TransformationOverview.newBuilder().build())
284             .build();
285     mockDlpService.addResponse(expectedResponse);
286 
287     DeidentifyContentRequest request =
288         DeidentifyContentRequest.newBuilder()
289             .setParent(ProjectName.of("[PROJECT]").toString())
290             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
291             .setInspectConfig(InspectConfig.newBuilder().build())
292             .setItem(ContentItem.newBuilder().build())
293             .setInspectTemplateName("inspectTemplateName1828857433")
294             .setDeidentifyTemplateName("deidentifyTemplateName-1374666414")
295             .setLocationId("locationId1541836720")
296             .build();
297 
298     DeidentifyContentResponse actualResponse = client.deidentifyContent(request);
299     Assert.assertEquals(expectedResponse, actualResponse);
300 
301     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
302     Assert.assertEquals(1, actualRequests.size());
303     DeidentifyContentRequest actualRequest = ((DeidentifyContentRequest) actualRequests.get(0));
304 
305     Assert.assertEquals(request.getParent(), actualRequest.getParent());
306     Assert.assertEquals(request.getDeidentifyConfig(), actualRequest.getDeidentifyConfig());
307     Assert.assertEquals(request.getInspectConfig(), actualRequest.getInspectConfig());
308     Assert.assertEquals(request.getItem(), actualRequest.getItem());
309     Assert.assertEquals(request.getInspectTemplateName(), actualRequest.getInspectTemplateName());
310     Assert.assertEquals(
311         request.getDeidentifyTemplateName(), actualRequest.getDeidentifyTemplateName());
312     Assert.assertEquals(request.getLocationId(), actualRequest.getLocationId());
313     Assert.assertTrue(
314         channelProvider.isHeaderSent(
315             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
316             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
317   }
318 
319   @Test
deidentifyContentExceptionTest()320   public void deidentifyContentExceptionTest() throws Exception {
321     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
322     mockDlpService.addException(exception);
323 
324     try {
325       DeidentifyContentRequest request =
326           DeidentifyContentRequest.newBuilder()
327               .setParent(ProjectName.of("[PROJECT]").toString())
328               .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
329               .setInspectConfig(InspectConfig.newBuilder().build())
330               .setItem(ContentItem.newBuilder().build())
331               .setInspectTemplateName("inspectTemplateName1828857433")
332               .setDeidentifyTemplateName("deidentifyTemplateName-1374666414")
333               .setLocationId("locationId1541836720")
334               .build();
335       client.deidentifyContent(request);
336       Assert.fail("No exception raised");
337     } catch (InvalidArgumentException e) {
338       // Expected exception.
339     }
340   }
341 
342   @Test
reidentifyContentTest()343   public void reidentifyContentTest() throws Exception {
344     ReidentifyContentResponse expectedResponse =
345         ReidentifyContentResponse.newBuilder()
346             .setItem(ContentItem.newBuilder().build())
347             .setOverview(TransformationOverview.newBuilder().build())
348             .build();
349     mockDlpService.addResponse(expectedResponse);
350 
351     ReidentifyContentRequest request =
352         ReidentifyContentRequest.newBuilder()
353             .setParent(ProjectName.of("[PROJECT]").toString())
354             .setReidentifyConfig(DeidentifyConfig.newBuilder().build())
355             .setInspectConfig(InspectConfig.newBuilder().build())
356             .setItem(ContentItem.newBuilder().build())
357             .setInspectTemplateName("inspectTemplateName1828857433")
358             .setReidentifyTemplateName("reidentifyTemplateName157316612")
359             .setLocationId("locationId1541836720")
360             .build();
361 
362     ReidentifyContentResponse actualResponse = client.reidentifyContent(request);
363     Assert.assertEquals(expectedResponse, actualResponse);
364 
365     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
366     Assert.assertEquals(1, actualRequests.size());
367     ReidentifyContentRequest actualRequest = ((ReidentifyContentRequest) actualRequests.get(0));
368 
369     Assert.assertEquals(request.getParent(), actualRequest.getParent());
370     Assert.assertEquals(request.getReidentifyConfig(), actualRequest.getReidentifyConfig());
371     Assert.assertEquals(request.getInspectConfig(), actualRequest.getInspectConfig());
372     Assert.assertEquals(request.getItem(), actualRequest.getItem());
373     Assert.assertEquals(request.getInspectTemplateName(), actualRequest.getInspectTemplateName());
374     Assert.assertEquals(
375         request.getReidentifyTemplateName(), actualRequest.getReidentifyTemplateName());
376     Assert.assertEquals(request.getLocationId(), actualRequest.getLocationId());
377     Assert.assertTrue(
378         channelProvider.isHeaderSent(
379             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
380             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
381   }
382 
383   @Test
reidentifyContentExceptionTest()384   public void reidentifyContentExceptionTest() throws Exception {
385     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
386     mockDlpService.addException(exception);
387 
388     try {
389       ReidentifyContentRequest request =
390           ReidentifyContentRequest.newBuilder()
391               .setParent(ProjectName.of("[PROJECT]").toString())
392               .setReidentifyConfig(DeidentifyConfig.newBuilder().build())
393               .setInspectConfig(InspectConfig.newBuilder().build())
394               .setItem(ContentItem.newBuilder().build())
395               .setInspectTemplateName("inspectTemplateName1828857433")
396               .setReidentifyTemplateName("reidentifyTemplateName157316612")
397               .setLocationId("locationId1541836720")
398               .build();
399       client.reidentifyContent(request);
400       Assert.fail("No exception raised");
401     } catch (InvalidArgumentException e) {
402       // Expected exception.
403     }
404   }
405 
406   @Test
listInfoTypesTest()407   public void listInfoTypesTest() throws Exception {
408     ListInfoTypesResponse expectedResponse =
409         ListInfoTypesResponse.newBuilder()
410             .addAllInfoTypes(new ArrayList<InfoTypeDescription>())
411             .build();
412     mockDlpService.addResponse(expectedResponse);
413 
414     String parent = "parent-995424086";
415 
416     ListInfoTypesResponse actualResponse = client.listInfoTypes(parent);
417     Assert.assertEquals(expectedResponse, actualResponse);
418 
419     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
420     Assert.assertEquals(1, actualRequests.size());
421     ListInfoTypesRequest actualRequest = ((ListInfoTypesRequest) actualRequests.get(0));
422 
423     Assert.assertEquals(parent, actualRequest.getParent());
424     Assert.assertTrue(
425         channelProvider.isHeaderSent(
426             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
427             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
428   }
429 
430   @Test
listInfoTypesExceptionTest()431   public void listInfoTypesExceptionTest() throws Exception {
432     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
433     mockDlpService.addException(exception);
434 
435     try {
436       String parent = "parent-995424086";
437       client.listInfoTypes(parent);
438       Assert.fail("No exception raised");
439     } catch (InvalidArgumentException e) {
440       // Expected exception.
441     }
442   }
443 
444   @Test
createInspectTemplateTest()445   public void createInspectTemplateTest() throws Exception {
446     InspectTemplate expectedResponse =
447         InspectTemplate.newBuilder()
448             .setName(
449                 InspectTemplateName.ofOrganizationInspectTemplateName(
450                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
451                     .toString())
452             .setDisplayName("displayName1714148973")
453             .setDescription("description-1724546052")
454             .setCreateTime(Timestamp.newBuilder().build())
455             .setUpdateTime(Timestamp.newBuilder().build())
456             .setInspectConfig(InspectConfig.newBuilder().build())
457             .build();
458     mockDlpService.addResponse(expectedResponse);
459 
460     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
461     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
462 
463     InspectTemplate actualResponse = client.createInspectTemplate(parent, inspectTemplate);
464     Assert.assertEquals(expectedResponse, actualResponse);
465 
466     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
467     Assert.assertEquals(1, actualRequests.size());
468     CreateInspectTemplateRequest actualRequest =
469         ((CreateInspectTemplateRequest) actualRequests.get(0));
470 
471     Assert.assertEquals(parent.toString(), actualRequest.getParent());
472     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
473     Assert.assertTrue(
474         channelProvider.isHeaderSent(
475             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
476             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
477   }
478 
479   @Test
createInspectTemplateExceptionTest()480   public void createInspectTemplateExceptionTest() throws Exception {
481     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
482     mockDlpService.addException(exception);
483 
484     try {
485       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
486       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
487       client.createInspectTemplate(parent, inspectTemplate);
488       Assert.fail("No exception raised");
489     } catch (InvalidArgumentException e) {
490       // Expected exception.
491     }
492   }
493 
494   @Test
createInspectTemplateTest2()495   public void createInspectTemplateTest2() throws Exception {
496     InspectTemplate expectedResponse =
497         InspectTemplate.newBuilder()
498             .setName(
499                 InspectTemplateName.ofOrganizationInspectTemplateName(
500                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
501                     .toString())
502             .setDisplayName("displayName1714148973")
503             .setDescription("description-1724546052")
504             .setCreateTime(Timestamp.newBuilder().build())
505             .setUpdateTime(Timestamp.newBuilder().build())
506             .setInspectConfig(InspectConfig.newBuilder().build())
507             .build();
508     mockDlpService.addResponse(expectedResponse);
509 
510     OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
511     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
512 
513     InspectTemplate actualResponse = client.createInspectTemplate(parent, inspectTemplate);
514     Assert.assertEquals(expectedResponse, actualResponse);
515 
516     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
517     Assert.assertEquals(1, actualRequests.size());
518     CreateInspectTemplateRequest actualRequest =
519         ((CreateInspectTemplateRequest) actualRequests.get(0));
520 
521     Assert.assertEquals(parent.toString(), actualRequest.getParent());
522     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
523     Assert.assertTrue(
524         channelProvider.isHeaderSent(
525             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
526             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
527   }
528 
529   @Test
createInspectTemplateExceptionTest2()530   public void createInspectTemplateExceptionTest2() throws Exception {
531     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
532     mockDlpService.addException(exception);
533 
534     try {
535       OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
536       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
537       client.createInspectTemplate(parent, inspectTemplate);
538       Assert.fail("No exception raised");
539     } catch (InvalidArgumentException e) {
540       // Expected exception.
541     }
542   }
543 
544   @Test
createInspectTemplateTest3()545   public void createInspectTemplateTest3() throws Exception {
546     InspectTemplate expectedResponse =
547         InspectTemplate.newBuilder()
548             .setName(
549                 InspectTemplateName.ofOrganizationInspectTemplateName(
550                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
551                     .toString())
552             .setDisplayName("displayName1714148973")
553             .setDescription("description-1724546052")
554             .setCreateTime(Timestamp.newBuilder().build())
555             .setUpdateTime(Timestamp.newBuilder().build())
556             .setInspectConfig(InspectConfig.newBuilder().build())
557             .build();
558     mockDlpService.addResponse(expectedResponse);
559 
560     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
561     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
562 
563     InspectTemplate actualResponse = client.createInspectTemplate(parent, inspectTemplate);
564     Assert.assertEquals(expectedResponse, actualResponse);
565 
566     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
567     Assert.assertEquals(1, actualRequests.size());
568     CreateInspectTemplateRequest actualRequest =
569         ((CreateInspectTemplateRequest) actualRequests.get(0));
570 
571     Assert.assertEquals(parent.toString(), actualRequest.getParent());
572     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
573     Assert.assertTrue(
574         channelProvider.isHeaderSent(
575             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
576             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
577   }
578 
579   @Test
createInspectTemplateExceptionTest3()580   public void createInspectTemplateExceptionTest3() throws Exception {
581     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
582     mockDlpService.addException(exception);
583 
584     try {
585       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
586       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
587       client.createInspectTemplate(parent, inspectTemplate);
588       Assert.fail("No exception raised");
589     } catch (InvalidArgumentException e) {
590       // Expected exception.
591     }
592   }
593 
594   @Test
createInspectTemplateTest4()595   public void createInspectTemplateTest4() throws Exception {
596     InspectTemplate expectedResponse =
597         InspectTemplate.newBuilder()
598             .setName(
599                 InspectTemplateName.ofOrganizationInspectTemplateName(
600                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
601                     .toString())
602             .setDisplayName("displayName1714148973")
603             .setDescription("description-1724546052")
604             .setCreateTime(Timestamp.newBuilder().build())
605             .setUpdateTime(Timestamp.newBuilder().build())
606             .setInspectConfig(InspectConfig.newBuilder().build())
607             .build();
608     mockDlpService.addResponse(expectedResponse);
609 
610     ProjectName parent = ProjectName.of("[PROJECT]");
611     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
612 
613     InspectTemplate actualResponse = client.createInspectTemplate(parent, inspectTemplate);
614     Assert.assertEquals(expectedResponse, actualResponse);
615 
616     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
617     Assert.assertEquals(1, actualRequests.size());
618     CreateInspectTemplateRequest actualRequest =
619         ((CreateInspectTemplateRequest) actualRequests.get(0));
620 
621     Assert.assertEquals(parent.toString(), actualRequest.getParent());
622     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
623     Assert.assertTrue(
624         channelProvider.isHeaderSent(
625             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
626             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
627   }
628 
629   @Test
createInspectTemplateExceptionTest4()630   public void createInspectTemplateExceptionTest4() throws Exception {
631     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
632     mockDlpService.addException(exception);
633 
634     try {
635       ProjectName parent = ProjectName.of("[PROJECT]");
636       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
637       client.createInspectTemplate(parent, inspectTemplate);
638       Assert.fail("No exception raised");
639     } catch (InvalidArgumentException e) {
640       // Expected exception.
641     }
642   }
643 
644   @Test
createInspectTemplateTest5()645   public void createInspectTemplateTest5() throws Exception {
646     InspectTemplate expectedResponse =
647         InspectTemplate.newBuilder()
648             .setName(
649                 InspectTemplateName.ofOrganizationInspectTemplateName(
650                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
651                     .toString())
652             .setDisplayName("displayName1714148973")
653             .setDescription("description-1724546052")
654             .setCreateTime(Timestamp.newBuilder().build())
655             .setUpdateTime(Timestamp.newBuilder().build())
656             .setInspectConfig(InspectConfig.newBuilder().build())
657             .build();
658     mockDlpService.addResponse(expectedResponse);
659 
660     String parent = "parent-995424086";
661     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
662 
663     InspectTemplate actualResponse = client.createInspectTemplate(parent, inspectTemplate);
664     Assert.assertEquals(expectedResponse, actualResponse);
665 
666     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
667     Assert.assertEquals(1, actualRequests.size());
668     CreateInspectTemplateRequest actualRequest =
669         ((CreateInspectTemplateRequest) actualRequests.get(0));
670 
671     Assert.assertEquals(parent, actualRequest.getParent());
672     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
673     Assert.assertTrue(
674         channelProvider.isHeaderSent(
675             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
676             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
677   }
678 
679   @Test
createInspectTemplateExceptionTest5()680   public void createInspectTemplateExceptionTest5() throws Exception {
681     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
682     mockDlpService.addException(exception);
683 
684     try {
685       String parent = "parent-995424086";
686       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
687       client.createInspectTemplate(parent, inspectTemplate);
688       Assert.fail("No exception raised");
689     } catch (InvalidArgumentException e) {
690       // Expected exception.
691     }
692   }
693 
694   @Test
updateInspectTemplateTest()695   public void updateInspectTemplateTest() throws Exception {
696     InspectTemplate expectedResponse =
697         InspectTemplate.newBuilder()
698             .setName(
699                 InspectTemplateName.ofOrganizationInspectTemplateName(
700                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
701                     .toString())
702             .setDisplayName("displayName1714148973")
703             .setDescription("description-1724546052")
704             .setCreateTime(Timestamp.newBuilder().build())
705             .setUpdateTime(Timestamp.newBuilder().build())
706             .setInspectConfig(InspectConfig.newBuilder().build())
707             .build();
708     mockDlpService.addResponse(expectedResponse);
709 
710     InspectTemplateName name =
711         InspectTemplateName.ofOrganizationInspectTemplateName(
712             "[ORGANIZATION]", "[INSPECT_TEMPLATE]");
713     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
714     FieldMask updateMask = FieldMask.newBuilder().build();
715 
716     InspectTemplate actualResponse =
717         client.updateInspectTemplate(name, inspectTemplate, updateMask);
718     Assert.assertEquals(expectedResponse, actualResponse);
719 
720     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
721     Assert.assertEquals(1, actualRequests.size());
722     UpdateInspectTemplateRequest actualRequest =
723         ((UpdateInspectTemplateRequest) actualRequests.get(0));
724 
725     Assert.assertEquals(name.toString(), actualRequest.getName());
726     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
727     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
728     Assert.assertTrue(
729         channelProvider.isHeaderSent(
730             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
731             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
732   }
733 
734   @Test
updateInspectTemplateExceptionTest()735   public void updateInspectTemplateExceptionTest() throws Exception {
736     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
737     mockDlpService.addException(exception);
738 
739     try {
740       InspectTemplateName name =
741           InspectTemplateName.ofOrganizationInspectTemplateName(
742               "[ORGANIZATION]", "[INSPECT_TEMPLATE]");
743       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
744       FieldMask updateMask = FieldMask.newBuilder().build();
745       client.updateInspectTemplate(name, inspectTemplate, updateMask);
746       Assert.fail("No exception raised");
747     } catch (InvalidArgumentException e) {
748       // Expected exception.
749     }
750   }
751 
752   @Test
updateInspectTemplateTest2()753   public void updateInspectTemplateTest2() throws Exception {
754     InspectTemplate expectedResponse =
755         InspectTemplate.newBuilder()
756             .setName(
757                 InspectTemplateName.ofOrganizationInspectTemplateName(
758                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
759                     .toString())
760             .setDisplayName("displayName1714148973")
761             .setDescription("description-1724546052")
762             .setCreateTime(Timestamp.newBuilder().build())
763             .setUpdateTime(Timestamp.newBuilder().build())
764             .setInspectConfig(InspectConfig.newBuilder().build())
765             .build();
766     mockDlpService.addResponse(expectedResponse);
767 
768     String name = "name3373707";
769     InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
770     FieldMask updateMask = FieldMask.newBuilder().build();
771 
772     InspectTemplate actualResponse =
773         client.updateInspectTemplate(name, inspectTemplate, updateMask);
774     Assert.assertEquals(expectedResponse, actualResponse);
775 
776     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
777     Assert.assertEquals(1, actualRequests.size());
778     UpdateInspectTemplateRequest actualRequest =
779         ((UpdateInspectTemplateRequest) actualRequests.get(0));
780 
781     Assert.assertEquals(name, actualRequest.getName());
782     Assert.assertEquals(inspectTemplate, actualRequest.getInspectTemplate());
783     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
784     Assert.assertTrue(
785         channelProvider.isHeaderSent(
786             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
787             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
788   }
789 
790   @Test
updateInspectTemplateExceptionTest2()791   public void updateInspectTemplateExceptionTest2() throws Exception {
792     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
793     mockDlpService.addException(exception);
794 
795     try {
796       String name = "name3373707";
797       InspectTemplate inspectTemplate = InspectTemplate.newBuilder().build();
798       FieldMask updateMask = FieldMask.newBuilder().build();
799       client.updateInspectTemplate(name, inspectTemplate, updateMask);
800       Assert.fail("No exception raised");
801     } catch (InvalidArgumentException e) {
802       // Expected exception.
803     }
804   }
805 
806   @Test
getInspectTemplateTest()807   public void getInspectTemplateTest() throws Exception {
808     InspectTemplate expectedResponse =
809         InspectTemplate.newBuilder()
810             .setName(
811                 InspectTemplateName.ofOrganizationInspectTemplateName(
812                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
813                     .toString())
814             .setDisplayName("displayName1714148973")
815             .setDescription("description-1724546052")
816             .setCreateTime(Timestamp.newBuilder().build())
817             .setUpdateTime(Timestamp.newBuilder().build())
818             .setInspectConfig(InspectConfig.newBuilder().build())
819             .build();
820     mockDlpService.addResponse(expectedResponse);
821 
822     InspectTemplateName name =
823         InspectTemplateName.ofOrganizationInspectTemplateName(
824             "[ORGANIZATION]", "[INSPECT_TEMPLATE]");
825 
826     InspectTemplate actualResponse = client.getInspectTemplate(name);
827     Assert.assertEquals(expectedResponse, actualResponse);
828 
829     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
830     Assert.assertEquals(1, actualRequests.size());
831     GetInspectTemplateRequest actualRequest = ((GetInspectTemplateRequest) actualRequests.get(0));
832 
833     Assert.assertEquals(name.toString(), actualRequest.getName());
834     Assert.assertTrue(
835         channelProvider.isHeaderSent(
836             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
837             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
838   }
839 
840   @Test
getInspectTemplateExceptionTest()841   public void getInspectTemplateExceptionTest() throws Exception {
842     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
843     mockDlpService.addException(exception);
844 
845     try {
846       InspectTemplateName name =
847           InspectTemplateName.ofOrganizationInspectTemplateName(
848               "[ORGANIZATION]", "[INSPECT_TEMPLATE]");
849       client.getInspectTemplate(name);
850       Assert.fail("No exception raised");
851     } catch (InvalidArgumentException e) {
852       // Expected exception.
853     }
854   }
855 
856   @Test
getInspectTemplateTest2()857   public void getInspectTemplateTest2() throws Exception {
858     InspectTemplate expectedResponse =
859         InspectTemplate.newBuilder()
860             .setName(
861                 InspectTemplateName.ofOrganizationInspectTemplateName(
862                         "[ORGANIZATION]", "[INSPECT_TEMPLATE]")
863                     .toString())
864             .setDisplayName("displayName1714148973")
865             .setDescription("description-1724546052")
866             .setCreateTime(Timestamp.newBuilder().build())
867             .setUpdateTime(Timestamp.newBuilder().build())
868             .setInspectConfig(InspectConfig.newBuilder().build())
869             .build();
870     mockDlpService.addResponse(expectedResponse);
871 
872     String name = "name3373707";
873 
874     InspectTemplate actualResponse = client.getInspectTemplate(name);
875     Assert.assertEquals(expectedResponse, actualResponse);
876 
877     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
878     Assert.assertEquals(1, actualRequests.size());
879     GetInspectTemplateRequest actualRequest = ((GetInspectTemplateRequest) actualRequests.get(0));
880 
881     Assert.assertEquals(name, actualRequest.getName());
882     Assert.assertTrue(
883         channelProvider.isHeaderSent(
884             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
885             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
886   }
887 
888   @Test
getInspectTemplateExceptionTest2()889   public void getInspectTemplateExceptionTest2() throws Exception {
890     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
891     mockDlpService.addException(exception);
892 
893     try {
894       String name = "name3373707";
895       client.getInspectTemplate(name);
896       Assert.fail("No exception raised");
897     } catch (InvalidArgumentException e) {
898       // Expected exception.
899     }
900   }
901 
902   @Test
listInspectTemplatesTest()903   public void listInspectTemplatesTest() throws Exception {
904     InspectTemplate responsesElement = InspectTemplate.newBuilder().build();
905     ListInspectTemplatesResponse expectedResponse =
906         ListInspectTemplatesResponse.newBuilder()
907             .setNextPageToken("")
908             .addAllInspectTemplates(Arrays.asList(responsesElement))
909             .build();
910     mockDlpService.addResponse(expectedResponse);
911 
912     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
913 
914     ListInspectTemplatesPagedResponse pagedListResponse = client.listInspectTemplates(parent);
915 
916     List<InspectTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
917 
918     Assert.assertEquals(1, resources.size());
919     Assert.assertEquals(expectedResponse.getInspectTemplatesList().get(0), resources.get(0));
920 
921     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
922     Assert.assertEquals(1, actualRequests.size());
923     ListInspectTemplatesRequest actualRequest =
924         ((ListInspectTemplatesRequest) actualRequests.get(0));
925 
926     Assert.assertEquals(parent.toString(), actualRequest.getParent());
927     Assert.assertTrue(
928         channelProvider.isHeaderSent(
929             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
930             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
931   }
932 
933   @Test
listInspectTemplatesExceptionTest()934   public void listInspectTemplatesExceptionTest() throws Exception {
935     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
936     mockDlpService.addException(exception);
937 
938     try {
939       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
940       client.listInspectTemplates(parent);
941       Assert.fail("No exception raised");
942     } catch (InvalidArgumentException e) {
943       // Expected exception.
944     }
945   }
946 
947   @Test
listInspectTemplatesTest2()948   public void listInspectTemplatesTest2() throws Exception {
949     InspectTemplate responsesElement = InspectTemplate.newBuilder().build();
950     ListInspectTemplatesResponse expectedResponse =
951         ListInspectTemplatesResponse.newBuilder()
952             .setNextPageToken("")
953             .addAllInspectTemplates(Arrays.asList(responsesElement))
954             .build();
955     mockDlpService.addResponse(expectedResponse);
956 
957     OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
958 
959     ListInspectTemplatesPagedResponse pagedListResponse = client.listInspectTemplates(parent);
960 
961     List<InspectTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
962 
963     Assert.assertEquals(1, resources.size());
964     Assert.assertEquals(expectedResponse.getInspectTemplatesList().get(0), resources.get(0));
965 
966     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
967     Assert.assertEquals(1, actualRequests.size());
968     ListInspectTemplatesRequest actualRequest =
969         ((ListInspectTemplatesRequest) actualRequests.get(0));
970 
971     Assert.assertEquals(parent.toString(), actualRequest.getParent());
972     Assert.assertTrue(
973         channelProvider.isHeaderSent(
974             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
975             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
976   }
977 
978   @Test
listInspectTemplatesExceptionTest2()979   public void listInspectTemplatesExceptionTest2() throws Exception {
980     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
981     mockDlpService.addException(exception);
982 
983     try {
984       OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
985       client.listInspectTemplates(parent);
986       Assert.fail("No exception raised");
987     } catch (InvalidArgumentException e) {
988       // Expected exception.
989     }
990   }
991 
992   @Test
listInspectTemplatesTest3()993   public void listInspectTemplatesTest3() throws Exception {
994     InspectTemplate responsesElement = InspectTemplate.newBuilder().build();
995     ListInspectTemplatesResponse expectedResponse =
996         ListInspectTemplatesResponse.newBuilder()
997             .setNextPageToken("")
998             .addAllInspectTemplates(Arrays.asList(responsesElement))
999             .build();
1000     mockDlpService.addResponse(expectedResponse);
1001 
1002     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1003 
1004     ListInspectTemplatesPagedResponse pagedListResponse = client.listInspectTemplates(parent);
1005 
1006     List<InspectTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1007 
1008     Assert.assertEquals(1, resources.size());
1009     Assert.assertEquals(expectedResponse.getInspectTemplatesList().get(0), resources.get(0));
1010 
1011     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1012     Assert.assertEquals(1, actualRequests.size());
1013     ListInspectTemplatesRequest actualRequest =
1014         ((ListInspectTemplatesRequest) actualRequests.get(0));
1015 
1016     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1017     Assert.assertTrue(
1018         channelProvider.isHeaderSent(
1019             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1020             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1021   }
1022 
1023   @Test
listInspectTemplatesExceptionTest3()1024   public void listInspectTemplatesExceptionTest3() throws Exception {
1025     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1026     mockDlpService.addException(exception);
1027 
1028     try {
1029       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1030       client.listInspectTemplates(parent);
1031       Assert.fail("No exception raised");
1032     } catch (InvalidArgumentException e) {
1033       // Expected exception.
1034     }
1035   }
1036 
1037   @Test
listInspectTemplatesTest4()1038   public void listInspectTemplatesTest4() throws Exception {
1039     InspectTemplate responsesElement = InspectTemplate.newBuilder().build();
1040     ListInspectTemplatesResponse expectedResponse =
1041         ListInspectTemplatesResponse.newBuilder()
1042             .setNextPageToken("")
1043             .addAllInspectTemplates(Arrays.asList(responsesElement))
1044             .build();
1045     mockDlpService.addResponse(expectedResponse);
1046 
1047     ProjectName parent = ProjectName.of("[PROJECT]");
1048 
1049     ListInspectTemplatesPagedResponse pagedListResponse = client.listInspectTemplates(parent);
1050 
1051     List<InspectTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1052 
1053     Assert.assertEquals(1, resources.size());
1054     Assert.assertEquals(expectedResponse.getInspectTemplatesList().get(0), resources.get(0));
1055 
1056     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1057     Assert.assertEquals(1, actualRequests.size());
1058     ListInspectTemplatesRequest actualRequest =
1059         ((ListInspectTemplatesRequest) actualRequests.get(0));
1060 
1061     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1062     Assert.assertTrue(
1063         channelProvider.isHeaderSent(
1064             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1065             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1066   }
1067 
1068   @Test
listInspectTemplatesExceptionTest4()1069   public void listInspectTemplatesExceptionTest4() throws Exception {
1070     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1071     mockDlpService.addException(exception);
1072 
1073     try {
1074       ProjectName parent = ProjectName.of("[PROJECT]");
1075       client.listInspectTemplates(parent);
1076       Assert.fail("No exception raised");
1077     } catch (InvalidArgumentException e) {
1078       // Expected exception.
1079     }
1080   }
1081 
1082   @Test
listInspectTemplatesTest5()1083   public void listInspectTemplatesTest5() throws Exception {
1084     InspectTemplate responsesElement = InspectTemplate.newBuilder().build();
1085     ListInspectTemplatesResponse expectedResponse =
1086         ListInspectTemplatesResponse.newBuilder()
1087             .setNextPageToken("")
1088             .addAllInspectTemplates(Arrays.asList(responsesElement))
1089             .build();
1090     mockDlpService.addResponse(expectedResponse);
1091 
1092     String parent = "parent-995424086";
1093 
1094     ListInspectTemplatesPagedResponse pagedListResponse = client.listInspectTemplates(parent);
1095 
1096     List<InspectTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1097 
1098     Assert.assertEquals(1, resources.size());
1099     Assert.assertEquals(expectedResponse.getInspectTemplatesList().get(0), resources.get(0));
1100 
1101     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1102     Assert.assertEquals(1, actualRequests.size());
1103     ListInspectTemplatesRequest actualRequest =
1104         ((ListInspectTemplatesRequest) actualRequests.get(0));
1105 
1106     Assert.assertEquals(parent, actualRequest.getParent());
1107     Assert.assertTrue(
1108         channelProvider.isHeaderSent(
1109             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1110             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1111   }
1112 
1113   @Test
listInspectTemplatesExceptionTest5()1114   public void listInspectTemplatesExceptionTest5() throws Exception {
1115     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1116     mockDlpService.addException(exception);
1117 
1118     try {
1119       String parent = "parent-995424086";
1120       client.listInspectTemplates(parent);
1121       Assert.fail("No exception raised");
1122     } catch (InvalidArgumentException e) {
1123       // Expected exception.
1124     }
1125   }
1126 
1127   @Test
deleteInspectTemplateTest()1128   public void deleteInspectTemplateTest() throws Exception {
1129     Empty expectedResponse = Empty.newBuilder().build();
1130     mockDlpService.addResponse(expectedResponse);
1131 
1132     InspectTemplateName name =
1133         InspectTemplateName.ofOrganizationInspectTemplateName(
1134             "[ORGANIZATION]", "[INSPECT_TEMPLATE]");
1135 
1136     client.deleteInspectTemplate(name);
1137 
1138     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1139     Assert.assertEquals(1, actualRequests.size());
1140     DeleteInspectTemplateRequest actualRequest =
1141         ((DeleteInspectTemplateRequest) actualRequests.get(0));
1142 
1143     Assert.assertEquals(name.toString(), actualRequest.getName());
1144     Assert.assertTrue(
1145         channelProvider.isHeaderSent(
1146             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1147             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1148   }
1149 
1150   @Test
deleteInspectTemplateExceptionTest()1151   public void deleteInspectTemplateExceptionTest() throws Exception {
1152     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1153     mockDlpService.addException(exception);
1154 
1155     try {
1156       InspectTemplateName name =
1157           InspectTemplateName.ofOrganizationInspectTemplateName(
1158               "[ORGANIZATION]", "[INSPECT_TEMPLATE]");
1159       client.deleteInspectTemplate(name);
1160       Assert.fail("No exception raised");
1161     } catch (InvalidArgumentException e) {
1162       // Expected exception.
1163     }
1164   }
1165 
1166   @Test
deleteInspectTemplateTest2()1167   public void deleteInspectTemplateTest2() throws Exception {
1168     Empty expectedResponse = Empty.newBuilder().build();
1169     mockDlpService.addResponse(expectedResponse);
1170 
1171     String name = "name3373707";
1172 
1173     client.deleteInspectTemplate(name);
1174 
1175     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1176     Assert.assertEquals(1, actualRequests.size());
1177     DeleteInspectTemplateRequest actualRequest =
1178         ((DeleteInspectTemplateRequest) actualRequests.get(0));
1179 
1180     Assert.assertEquals(name, actualRequest.getName());
1181     Assert.assertTrue(
1182         channelProvider.isHeaderSent(
1183             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1184             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1185   }
1186 
1187   @Test
deleteInspectTemplateExceptionTest2()1188   public void deleteInspectTemplateExceptionTest2() throws Exception {
1189     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1190     mockDlpService.addException(exception);
1191 
1192     try {
1193       String name = "name3373707";
1194       client.deleteInspectTemplate(name);
1195       Assert.fail("No exception raised");
1196     } catch (InvalidArgumentException e) {
1197       // Expected exception.
1198     }
1199   }
1200 
1201   @Test
createDeidentifyTemplateTest()1202   public void createDeidentifyTemplateTest() throws Exception {
1203     DeidentifyTemplate expectedResponse =
1204         DeidentifyTemplate.newBuilder()
1205             .setName(
1206                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1207                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1208                     .toString())
1209             .setDisplayName("displayName1714148973")
1210             .setDescription("description-1724546052")
1211             .setCreateTime(Timestamp.newBuilder().build())
1212             .setUpdateTime(Timestamp.newBuilder().build())
1213             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1214             .build();
1215     mockDlpService.addResponse(expectedResponse);
1216 
1217     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1218     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1219 
1220     DeidentifyTemplate actualResponse = client.createDeidentifyTemplate(parent, deidentifyTemplate);
1221     Assert.assertEquals(expectedResponse, actualResponse);
1222 
1223     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1224     Assert.assertEquals(1, actualRequests.size());
1225     CreateDeidentifyTemplateRequest actualRequest =
1226         ((CreateDeidentifyTemplateRequest) actualRequests.get(0));
1227 
1228     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1229     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1230     Assert.assertTrue(
1231         channelProvider.isHeaderSent(
1232             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1233             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1234   }
1235 
1236   @Test
createDeidentifyTemplateExceptionTest()1237   public void createDeidentifyTemplateExceptionTest() throws Exception {
1238     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1239     mockDlpService.addException(exception);
1240 
1241     try {
1242       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1243       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1244       client.createDeidentifyTemplate(parent, deidentifyTemplate);
1245       Assert.fail("No exception raised");
1246     } catch (InvalidArgumentException e) {
1247       // Expected exception.
1248     }
1249   }
1250 
1251   @Test
createDeidentifyTemplateTest2()1252   public void createDeidentifyTemplateTest2() throws Exception {
1253     DeidentifyTemplate expectedResponse =
1254         DeidentifyTemplate.newBuilder()
1255             .setName(
1256                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1257                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1258                     .toString())
1259             .setDisplayName("displayName1714148973")
1260             .setDescription("description-1724546052")
1261             .setCreateTime(Timestamp.newBuilder().build())
1262             .setUpdateTime(Timestamp.newBuilder().build())
1263             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1264             .build();
1265     mockDlpService.addResponse(expectedResponse);
1266 
1267     OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
1268     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1269 
1270     DeidentifyTemplate actualResponse = client.createDeidentifyTemplate(parent, deidentifyTemplate);
1271     Assert.assertEquals(expectedResponse, actualResponse);
1272 
1273     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1274     Assert.assertEquals(1, actualRequests.size());
1275     CreateDeidentifyTemplateRequest actualRequest =
1276         ((CreateDeidentifyTemplateRequest) actualRequests.get(0));
1277 
1278     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1279     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1280     Assert.assertTrue(
1281         channelProvider.isHeaderSent(
1282             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1283             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1284   }
1285 
1286   @Test
createDeidentifyTemplateExceptionTest2()1287   public void createDeidentifyTemplateExceptionTest2() throws Exception {
1288     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1289     mockDlpService.addException(exception);
1290 
1291     try {
1292       OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
1293       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1294       client.createDeidentifyTemplate(parent, deidentifyTemplate);
1295       Assert.fail("No exception raised");
1296     } catch (InvalidArgumentException e) {
1297       // Expected exception.
1298     }
1299   }
1300 
1301   @Test
createDeidentifyTemplateTest3()1302   public void createDeidentifyTemplateTest3() throws Exception {
1303     DeidentifyTemplate expectedResponse =
1304         DeidentifyTemplate.newBuilder()
1305             .setName(
1306                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1307                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1308                     .toString())
1309             .setDisplayName("displayName1714148973")
1310             .setDescription("description-1724546052")
1311             .setCreateTime(Timestamp.newBuilder().build())
1312             .setUpdateTime(Timestamp.newBuilder().build())
1313             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1314             .build();
1315     mockDlpService.addResponse(expectedResponse);
1316 
1317     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1318     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1319 
1320     DeidentifyTemplate actualResponse = client.createDeidentifyTemplate(parent, deidentifyTemplate);
1321     Assert.assertEquals(expectedResponse, actualResponse);
1322 
1323     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1324     Assert.assertEquals(1, actualRequests.size());
1325     CreateDeidentifyTemplateRequest actualRequest =
1326         ((CreateDeidentifyTemplateRequest) actualRequests.get(0));
1327 
1328     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1329     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1330     Assert.assertTrue(
1331         channelProvider.isHeaderSent(
1332             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1333             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1334   }
1335 
1336   @Test
createDeidentifyTemplateExceptionTest3()1337   public void createDeidentifyTemplateExceptionTest3() throws Exception {
1338     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1339     mockDlpService.addException(exception);
1340 
1341     try {
1342       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1343       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1344       client.createDeidentifyTemplate(parent, deidentifyTemplate);
1345       Assert.fail("No exception raised");
1346     } catch (InvalidArgumentException e) {
1347       // Expected exception.
1348     }
1349   }
1350 
1351   @Test
createDeidentifyTemplateTest4()1352   public void createDeidentifyTemplateTest4() throws Exception {
1353     DeidentifyTemplate expectedResponse =
1354         DeidentifyTemplate.newBuilder()
1355             .setName(
1356                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1357                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1358                     .toString())
1359             .setDisplayName("displayName1714148973")
1360             .setDescription("description-1724546052")
1361             .setCreateTime(Timestamp.newBuilder().build())
1362             .setUpdateTime(Timestamp.newBuilder().build())
1363             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1364             .build();
1365     mockDlpService.addResponse(expectedResponse);
1366 
1367     ProjectName parent = ProjectName.of("[PROJECT]");
1368     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1369 
1370     DeidentifyTemplate actualResponse = client.createDeidentifyTemplate(parent, deidentifyTemplate);
1371     Assert.assertEquals(expectedResponse, actualResponse);
1372 
1373     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1374     Assert.assertEquals(1, actualRequests.size());
1375     CreateDeidentifyTemplateRequest actualRequest =
1376         ((CreateDeidentifyTemplateRequest) actualRequests.get(0));
1377 
1378     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1379     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1380     Assert.assertTrue(
1381         channelProvider.isHeaderSent(
1382             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1383             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1384   }
1385 
1386   @Test
createDeidentifyTemplateExceptionTest4()1387   public void createDeidentifyTemplateExceptionTest4() throws Exception {
1388     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1389     mockDlpService.addException(exception);
1390 
1391     try {
1392       ProjectName parent = ProjectName.of("[PROJECT]");
1393       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1394       client.createDeidentifyTemplate(parent, deidentifyTemplate);
1395       Assert.fail("No exception raised");
1396     } catch (InvalidArgumentException e) {
1397       // Expected exception.
1398     }
1399   }
1400 
1401   @Test
createDeidentifyTemplateTest5()1402   public void createDeidentifyTemplateTest5() throws Exception {
1403     DeidentifyTemplate expectedResponse =
1404         DeidentifyTemplate.newBuilder()
1405             .setName(
1406                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1407                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1408                     .toString())
1409             .setDisplayName("displayName1714148973")
1410             .setDescription("description-1724546052")
1411             .setCreateTime(Timestamp.newBuilder().build())
1412             .setUpdateTime(Timestamp.newBuilder().build())
1413             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1414             .build();
1415     mockDlpService.addResponse(expectedResponse);
1416 
1417     String parent = "parent-995424086";
1418     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1419 
1420     DeidentifyTemplate actualResponse = client.createDeidentifyTemplate(parent, deidentifyTemplate);
1421     Assert.assertEquals(expectedResponse, actualResponse);
1422 
1423     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1424     Assert.assertEquals(1, actualRequests.size());
1425     CreateDeidentifyTemplateRequest actualRequest =
1426         ((CreateDeidentifyTemplateRequest) actualRequests.get(0));
1427 
1428     Assert.assertEquals(parent, actualRequest.getParent());
1429     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1430     Assert.assertTrue(
1431         channelProvider.isHeaderSent(
1432             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1433             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1434   }
1435 
1436   @Test
createDeidentifyTemplateExceptionTest5()1437   public void createDeidentifyTemplateExceptionTest5() throws Exception {
1438     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1439     mockDlpService.addException(exception);
1440 
1441     try {
1442       String parent = "parent-995424086";
1443       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1444       client.createDeidentifyTemplate(parent, deidentifyTemplate);
1445       Assert.fail("No exception raised");
1446     } catch (InvalidArgumentException e) {
1447       // Expected exception.
1448     }
1449   }
1450 
1451   @Test
updateDeidentifyTemplateTest()1452   public void updateDeidentifyTemplateTest() throws Exception {
1453     DeidentifyTemplate expectedResponse =
1454         DeidentifyTemplate.newBuilder()
1455             .setName(
1456                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1457                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1458                     .toString())
1459             .setDisplayName("displayName1714148973")
1460             .setDescription("description-1724546052")
1461             .setCreateTime(Timestamp.newBuilder().build())
1462             .setUpdateTime(Timestamp.newBuilder().build())
1463             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1464             .build();
1465     mockDlpService.addResponse(expectedResponse);
1466 
1467     DeidentifyTemplateName name =
1468         DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1469             "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]");
1470     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1471     FieldMask updateMask = FieldMask.newBuilder().build();
1472 
1473     DeidentifyTemplate actualResponse =
1474         client.updateDeidentifyTemplate(name, deidentifyTemplate, updateMask);
1475     Assert.assertEquals(expectedResponse, actualResponse);
1476 
1477     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1478     Assert.assertEquals(1, actualRequests.size());
1479     UpdateDeidentifyTemplateRequest actualRequest =
1480         ((UpdateDeidentifyTemplateRequest) actualRequests.get(0));
1481 
1482     Assert.assertEquals(name.toString(), actualRequest.getName());
1483     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1484     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1485     Assert.assertTrue(
1486         channelProvider.isHeaderSent(
1487             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1488             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1489   }
1490 
1491   @Test
updateDeidentifyTemplateExceptionTest()1492   public void updateDeidentifyTemplateExceptionTest() throws Exception {
1493     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1494     mockDlpService.addException(exception);
1495 
1496     try {
1497       DeidentifyTemplateName name =
1498           DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1499               "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]");
1500       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1501       FieldMask updateMask = FieldMask.newBuilder().build();
1502       client.updateDeidentifyTemplate(name, deidentifyTemplate, updateMask);
1503       Assert.fail("No exception raised");
1504     } catch (InvalidArgumentException e) {
1505       // Expected exception.
1506     }
1507   }
1508 
1509   @Test
updateDeidentifyTemplateTest2()1510   public void updateDeidentifyTemplateTest2() throws Exception {
1511     DeidentifyTemplate expectedResponse =
1512         DeidentifyTemplate.newBuilder()
1513             .setName(
1514                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1515                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1516                     .toString())
1517             .setDisplayName("displayName1714148973")
1518             .setDescription("description-1724546052")
1519             .setCreateTime(Timestamp.newBuilder().build())
1520             .setUpdateTime(Timestamp.newBuilder().build())
1521             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1522             .build();
1523     mockDlpService.addResponse(expectedResponse);
1524 
1525     String name = "name3373707";
1526     DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1527     FieldMask updateMask = FieldMask.newBuilder().build();
1528 
1529     DeidentifyTemplate actualResponse =
1530         client.updateDeidentifyTemplate(name, deidentifyTemplate, updateMask);
1531     Assert.assertEquals(expectedResponse, actualResponse);
1532 
1533     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1534     Assert.assertEquals(1, actualRequests.size());
1535     UpdateDeidentifyTemplateRequest actualRequest =
1536         ((UpdateDeidentifyTemplateRequest) actualRequests.get(0));
1537 
1538     Assert.assertEquals(name, actualRequest.getName());
1539     Assert.assertEquals(deidentifyTemplate, actualRequest.getDeidentifyTemplate());
1540     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1541     Assert.assertTrue(
1542         channelProvider.isHeaderSent(
1543             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1544             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1545   }
1546 
1547   @Test
updateDeidentifyTemplateExceptionTest2()1548   public void updateDeidentifyTemplateExceptionTest2() throws Exception {
1549     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1550     mockDlpService.addException(exception);
1551 
1552     try {
1553       String name = "name3373707";
1554       DeidentifyTemplate deidentifyTemplate = DeidentifyTemplate.newBuilder().build();
1555       FieldMask updateMask = FieldMask.newBuilder().build();
1556       client.updateDeidentifyTemplate(name, deidentifyTemplate, updateMask);
1557       Assert.fail("No exception raised");
1558     } catch (InvalidArgumentException e) {
1559       // Expected exception.
1560     }
1561   }
1562 
1563   @Test
getDeidentifyTemplateTest()1564   public void getDeidentifyTemplateTest() throws Exception {
1565     DeidentifyTemplate expectedResponse =
1566         DeidentifyTemplate.newBuilder()
1567             .setName(
1568                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1569                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1570                     .toString())
1571             .setDisplayName("displayName1714148973")
1572             .setDescription("description-1724546052")
1573             .setCreateTime(Timestamp.newBuilder().build())
1574             .setUpdateTime(Timestamp.newBuilder().build())
1575             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1576             .build();
1577     mockDlpService.addResponse(expectedResponse);
1578 
1579     DeidentifyTemplateName name =
1580         DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1581             "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]");
1582 
1583     DeidentifyTemplate actualResponse = client.getDeidentifyTemplate(name);
1584     Assert.assertEquals(expectedResponse, actualResponse);
1585 
1586     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1587     Assert.assertEquals(1, actualRequests.size());
1588     GetDeidentifyTemplateRequest actualRequest =
1589         ((GetDeidentifyTemplateRequest) actualRequests.get(0));
1590 
1591     Assert.assertEquals(name.toString(), actualRequest.getName());
1592     Assert.assertTrue(
1593         channelProvider.isHeaderSent(
1594             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1595             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1596   }
1597 
1598   @Test
getDeidentifyTemplateExceptionTest()1599   public void getDeidentifyTemplateExceptionTest() throws Exception {
1600     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1601     mockDlpService.addException(exception);
1602 
1603     try {
1604       DeidentifyTemplateName name =
1605           DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1606               "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]");
1607       client.getDeidentifyTemplate(name);
1608       Assert.fail("No exception raised");
1609     } catch (InvalidArgumentException e) {
1610       // Expected exception.
1611     }
1612   }
1613 
1614   @Test
getDeidentifyTemplateTest2()1615   public void getDeidentifyTemplateTest2() throws Exception {
1616     DeidentifyTemplate expectedResponse =
1617         DeidentifyTemplate.newBuilder()
1618             .setName(
1619                 DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1620                         "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]")
1621                     .toString())
1622             .setDisplayName("displayName1714148973")
1623             .setDescription("description-1724546052")
1624             .setCreateTime(Timestamp.newBuilder().build())
1625             .setUpdateTime(Timestamp.newBuilder().build())
1626             .setDeidentifyConfig(DeidentifyConfig.newBuilder().build())
1627             .build();
1628     mockDlpService.addResponse(expectedResponse);
1629 
1630     String name = "name3373707";
1631 
1632     DeidentifyTemplate actualResponse = client.getDeidentifyTemplate(name);
1633     Assert.assertEquals(expectedResponse, actualResponse);
1634 
1635     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1636     Assert.assertEquals(1, actualRequests.size());
1637     GetDeidentifyTemplateRequest actualRequest =
1638         ((GetDeidentifyTemplateRequest) actualRequests.get(0));
1639 
1640     Assert.assertEquals(name, actualRequest.getName());
1641     Assert.assertTrue(
1642         channelProvider.isHeaderSent(
1643             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1644             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1645   }
1646 
1647   @Test
getDeidentifyTemplateExceptionTest2()1648   public void getDeidentifyTemplateExceptionTest2() throws Exception {
1649     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1650     mockDlpService.addException(exception);
1651 
1652     try {
1653       String name = "name3373707";
1654       client.getDeidentifyTemplate(name);
1655       Assert.fail("No exception raised");
1656     } catch (InvalidArgumentException e) {
1657       // Expected exception.
1658     }
1659   }
1660 
1661   @Test
listDeidentifyTemplatesTest()1662   public void listDeidentifyTemplatesTest() throws Exception {
1663     DeidentifyTemplate responsesElement = DeidentifyTemplate.newBuilder().build();
1664     ListDeidentifyTemplatesResponse expectedResponse =
1665         ListDeidentifyTemplatesResponse.newBuilder()
1666             .setNextPageToken("")
1667             .addAllDeidentifyTemplates(Arrays.asList(responsesElement))
1668             .build();
1669     mockDlpService.addResponse(expectedResponse);
1670 
1671     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1672 
1673     ListDeidentifyTemplatesPagedResponse pagedListResponse = client.listDeidentifyTemplates(parent);
1674 
1675     List<DeidentifyTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1676 
1677     Assert.assertEquals(1, resources.size());
1678     Assert.assertEquals(expectedResponse.getDeidentifyTemplatesList().get(0), resources.get(0));
1679 
1680     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1681     Assert.assertEquals(1, actualRequests.size());
1682     ListDeidentifyTemplatesRequest actualRequest =
1683         ((ListDeidentifyTemplatesRequest) actualRequests.get(0));
1684 
1685     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1686     Assert.assertTrue(
1687         channelProvider.isHeaderSent(
1688             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1689             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1690   }
1691 
1692   @Test
listDeidentifyTemplatesExceptionTest()1693   public void listDeidentifyTemplatesExceptionTest() throws Exception {
1694     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1695     mockDlpService.addException(exception);
1696 
1697     try {
1698       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1699       client.listDeidentifyTemplates(parent);
1700       Assert.fail("No exception raised");
1701     } catch (InvalidArgumentException e) {
1702       // Expected exception.
1703     }
1704   }
1705 
1706   @Test
listDeidentifyTemplatesTest2()1707   public void listDeidentifyTemplatesTest2() throws Exception {
1708     DeidentifyTemplate responsesElement = DeidentifyTemplate.newBuilder().build();
1709     ListDeidentifyTemplatesResponse expectedResponse =
1710         ListDeidentifyTemplatesResponse.newBuilder()
1711             .setNextPageToken("")
1712             .addAllDeidentifyTemplates(Arrays.asList(responsesElement))
1713             .build();
1714     mockDlpService.addResponse(expectedResponse);
1715 
1716     OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
1717 
1718     ListDeidentifyTemplatesPagedResponse pagedListResponse = client.listDeidentifyTemplates(parent);
1719 
1720     List<DeidentifyTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1721 
1722     Assert.assertEquals(1, resources.size());
1723     Assert.assertEquals(expectedResponse.getDeidentifyTemplatesList().get(0), resources.get(0));
1724 
1725     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1726     Assert.assertEquals(1, actualRequests.size());
1727     ListDeidentifyTemplatesRequest actualRequest =
1728         ((ListDeidentifyTemplatesRequest) actualRequests.get(0));
1729 
1730     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1731     Assert.assertTrue(
1732         channelProvider.isHeaderSent(
1733             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1734             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1735   }
1736 
1737   @Test
listDeidentifyTemplatesExceptionTest2()1738   public void listDeidentifyTemplatesExceptionTest2() throws Exception {
1739     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1740     mockDlpService.addException(exception);
1741 
1742     try {
1743       OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
1744       client.listDeidentifyTemplates(parent);
1745       Assert.fail("No exception raised");
1746     } catch (InvalidArgumentException e) {
1747       // Expected exception.
1748     }
1749   }
1750 
1751   @Test
listDeidentifyTemplatesTest3()1752   public void listDeidentifyTemplatesTest3() throws Exception {
1753     DeidentifyTemplate responsesElement = DeidentifyTemplate.newBuilder().build();
1754     ListDeidentifyTemplatesResponse expectedResponse =
1755         ListDeidentifyTemplatesResponse.newBuilder()
1756             .setNextPageToken("")
1757             .addAllDeidentifyTemplates(Arrays.asList(responsesElement))
1758             .build();
1759     mockDlpService.addResponse(expectedResponse);
1760 
1761     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1762 
1763     ListDeidentifyTemplatesPagedResponse pagedListResponse = client.listDeidentifyTemplates(parent);
1764 
1765     List<DeidentifyTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1766 
1767     Assert.assertEquals(1, resources.size());
1768     Assert.assertEquals(expectedResponse.getDeidentifyTemplatesList().get(0), resources.get(0));
1769 
1770     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1771     Assert.assertEquals(1, actualRequests.size());
1772     ListDeidentifyTemplatesRequest actualRequest =
1773         ((ListDeidentifyTemplatesRequest) actualRequests.get(0));
1774 
1775     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1776     Assert.assertTrue(
1777         channelProvider.isHeaderSent(
1778             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1779             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1780   }
1781 
1782   @Test
listDeidentifyTemplatesExceptionTest3()1783   public void listDeidentifyTemplatesExceptionTest3() throws Exception {
1784     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1785     mockDlpService.addException(exception);
1786 
1787     try {
1788       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
1789       client.listDeidentifyTemplates(parent);
1790       Assert.fail("No exception raised");
1791     } catch (InvalidArgumentException e) {
1792       // Expected exception.
1793     }
1794   }
1795 
1796   @Test
listDeidentifyTemplatesTest4()1797   public void listDeidentifyTemplatesTest4() throws Exception {
1798     DeidentifyTemplate responsesElement = DeidentifyTemplate.newBuilder().build();
1799     ListDeidentifyTemplatesResponse expectedResponse =
1800         ListDeidentifyTemplatesResponse.newBuilder()
1801             .setNextPageToken("")
1802             .addAllDeidentifyTemplates(Arrays.asList(responsesElement))
1803             .build();
1804     mockDlpService.addResponse(expectedResponse);
1805 
1806     ProjectName parent = ProjectName.of("[PROJECT]");
1807 
1808     ListDeidentifyTemplatesPagedResponse pagedListResponse = client.listDeidentifyTemplates(parent);
1809 
1810     List<DeidentifyTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1811 
1812     Assert.assertEquals(1, resources.size());
1813     Assert.assertEquals(expectedResponse.getDeidentifyTemplatesList().get(0), resources.get(0));
1814 
1815     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1816     Assert.assertEquals(1, actualRequests.size());
1817     ListDeidentifyTemplatesRequest actualRequest =
1818         ((ListDeidentifyTemplatesRequest) actualRequests.get(0));
1819 
1820     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1821     Assert.assertTrue(
1822         channelProvider.isHeaderSent(
1823             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1824             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1825   }
1826 
1827   @Test
listDeidentifyTemplatesExceptionTest4()1828   public void listDeidentifyTemplatesExceptionTest4() throws Exception {
1829     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1830     mockDlpService.addException(exception);
1831 
1832     try {
1833       ProjectName parent = ProjectName.of("[PROJECT]");
1834       client.listDeidentifyTemplates(parent);
1835       Assert.fail("No exception raised");
1836     } catch (InvalidArgumentException e) {
1837       // Expected exception.
1838     }
1839   }
1840 
1841   @Test
listDeidentifyTemplatesTest5()1842   public void listDeidentifyTemplatesTest5() throws Exception {
1843     DeidentifyTemplate responsesElement = DeidentifyTemplate.newBuilder().build();
1844     ListDeidentifyTemplatesResponse expectedResponse =
1845         ListDeidentifyTemplatesResponse.newBuilder()
1846             .setNextPageToken("")
1847             .addAllDeidentifyTemplates(Arrays.asList(responsesElement))
1848             .build();
1849     mockDlpService.addResponse(expectedResponse);
1850 
1851     String parent = "parent-995424086";
1852 
1853     ListDeidentifyTemplatesPagedResponse pagedListResponse = client.listDeidentifyTemplates(parent);
1854 
1855     List<DeidentifyTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1856 
1857     Assert.assertEquals(1, resources.size());
1858     Assert.assertEquals(expectedResponse.getDeidentifyTemplatesList().get(0), resources.get(0));
1859 
1860     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1861     Assert.assertEquals(1, actualRequests.size());
1862     ListDeidentifyTemplatesRequest actualRequest =
1863         ((ListDeidentifyTemplatesRequest) actualRequests.get(0));
1864 
1865     Assert.assertEquals(parent, actualRequest.getParent());
1866     Assert.assertTrue(
1867         channelProvider.isHeaderSent(
1868             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1869             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1870   }
1871 
1872   @Test
listDeidentifyTemplatesExceptionTest5()1873   public void listDeidentifyTemplatesExceptionTest5() throws Exception {
1874     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1875     mockDlpService.addException(exception);
1876 
1877     try {
1878       String parent = "parent-995424086";
1879       client.listDeidentifyTemplates(parent);
1880       Assert.fail("No exception raised");
1881     } catch (InvalidArgumentException e) {
1882       // Expected exception.
1883     }
1884   }
1885 
1886   @Test
deleteDeidentifyTemplateTest()1887   public void deleteDeidentifyTemplateTest() throws Exception {
1888     Empty expectedResponse = Empty.newBuilder().build();
1889     mockDlpService.addResponse(expectedResponse);
1890 
1891     DeidentifyTemplateName name =
1892         DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1893             "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]");
1894 
1895     client.deleteDeidentifyTemplate(name);
1896 
1897     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1898     Assert.assertEquals(1, actualRequests.size());
1899     DeleteDeidentifyTemplateRequest actualRequest =
1900         ((DeleteDeidentifyTemplateRequest) actualRequests.get(0));
1901 
1902     Assert.assertEquals(name.toString(), actualRequest.getName());
1903     Assert.assertTrue(
1904         channelProvider.isHeaderSent(
1905             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1906             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1907   }
1908 
1909   @Test
deleteDeidentifyTemplateExceptionTest()1910   public void deleteDeidentifyTemplateExceptionTest() throws Exception {
1911     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1912     mockDlpService.addException(exception);
1913 
1914     try {
1915       DeidentifyTemplateName name =
1916           DeidentifyTemplateName.ofOrganizationDeidentifyTemplateName(
1917               "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]");
1918       client.deleteDeidentifyTemplate(name);
1919       Assert.fail("No exception raised");
1920     } catch (InvalidArgumentException e) {
1921       // Expected exception.
1922     }
1923   }
1924 
1925   @Test
deleteDeidentifyTemplateTest2()1926   public void deleteDeidentifyTemplateTest2() throws Exception {
1927     Empty expectedResponse = Empty.newBuilder().build();
1928     mockDlpService.addResponse(expectedResponse);
1929 
1930     String name = "name3373707";
1931 
1932     client.deleteDeidentifyTemplate(name);
1933 
1934     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1935     Assert.assertEquals(1, actualRequests.size());
1936     DeleteDeidentifyTemplateRequest actualRequest =
1937         ((DeleteDeidentifyTemplateRequest) actualRequests.get(0));
1938 
1939     Assert.assertEquals(name, actualRequest.getName());
1940     Assert.assertTrue(
1941         channelProvider.isHeaderSent(
1942             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1943             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1944   }
1945 
1946   @Test
deleteDeidentifyTemplateExceptionTest2()1947   public void deleteDeidentifyTemplateExceptionTest2() throws Exception {
1948     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1949     mockDlpService.addException(exception);
1950 
1951     try {
1952       String name = "name3373707";
1953       client.deleteDeidentifyTemplate(name);
1954       Assert.fail("No exception raised");
1955     } catch (InvalidArgumentException e) {
1956       // Expected exception.
1957     }
1958   }
1959 
1960   @Test
createJobTriggerTest()1961   public void createJobTriggerTest() throws Exception {
1962     JobTrigger expectedResponse =
1963         JobTrigger.newBuilder()
1964             .setName(
1965                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
1966             .setDisplayName("displayName1714148973")
1967             .setDescription("description-1724546052")
1968             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
1969             .addAllErrors(new ArrayList<Error>())
1970             .setCreateTime(Timestamp.newBuilder().build())
1971             .setUpdateTime(Timestamp.newBuilder().build())
1972             .setLastRunTime(Timestamp.newBuilder().build())
1973             .build();
1974     mockDlpService.addResponse(expectedResponse);
1975 
1976     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1977     JobTrigger jobTrigger = JobTrigger.newBuilder().build();
1978 
1979     JobTrigger actualResponse = client.createJobTrigger(parent, jobTrigger);
1980     Assert.assertEquals(expectedResponse, actualResponse);
1981 
1982     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
1983     Assert.assertEquals(1, actualRequests.size());
1984     CreateJobTriggerRequest actualRequest = ((CreateJobTriggerRequest) actualRequests.get(0));
1985 
1986     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1987     Assert.assertEquals(jobTrigger, actualRequest.getJobTrigger());
1988     Assert.assertTrue(
1989         channelProvider.isHeaderSent(
1990             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1991             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1992   }
1993 
1994   @Test
createJobTriggerExceptionTest()1995   public void createJobTriggerExceptionTest() throws Exception {
1996     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1997     mockDlpService.addException(exception);
1998 
1999     try {
2000       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2001       JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2002       client.createJobTrigger(parent, jobTrigger);
2003       Assert.fail("No exception raised");
2004     } catch (InvalidArgumentException e) {
2005       // Expected exception.
2006     }
2007   }
2008 
2009   @Test
createJobTriggerTest2()2010   public void createJobTriggerTest2() throws Exception {
2011     JobTrigger expectedResponse =
2012         JobTrigger.newBuilder()
2013             .setName(
2014                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2015             .setDisplayName("displayName1714148973")
2016             .setDescription("description-1724546052")
2017             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
2018             .addAllErrors(new ArrayList<Error>())
2019             .setCreateTime(Timestamp.newBuilder().build())
2020             .setUpdateTime(Timestamp.newBuilder().build())
2021             .setLastRunTime(Timestamp.newBuilder().build())
2022             .build();
2023     mockDlpService.addResponse(expectedResponse);
2024 
2025     ProjectName parent = ProjectName.of("[PROJECT]");
2026     JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2027 
2028     JobTrigger actualResponse = client.createJobTrigger(parent, jobTrigger);
2029     Assert.assertEquals(expectedResponse, actualResponse);
2030 
2031     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2032     Assert.assertEquals(1, actualRequests.size());
2033     CreateJobTriggerRequest actualRequest = ((CreateJobTriggerRequest) actualRequests.get(0));
2034 
2035     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2036     Assert.assertEquals(jobTrigger, actualRequest.getJobTrigger());
2037     Assert.assertTrue(
2038         channelProvider.isHeaderSent(
2039             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2040             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2041   }
2042 
2043   @Test
createJobTriggerExceptionTest2()2044   public void createJobTriggerExceptionTest2() throws Exception {
2045     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2046     mockDlpService.addException(exception);
2047 
2048     try {
2049       ProjectName parent = ProjectName.of("[PROJECT]");
2050       JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2051       client.createJobTrigger(parent, jobTrigger);
2052       Assert.fail("No exception raised");
2053     } catch (InvalidArgumentException e) {
2054       // Expected exception.
2055     }
2056   }
2057 
2058   @Test
createJobTriggerTest3()2059   public void createJobTriggerTest3() throws Exception {
2060     JobTrigger expectedResponse =
2061         JobTrigger.newBuilder()
2062             .setName(
2063                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2064             .setDisplayName("displayName1714148973")
2065             .setDescription("description-1724546052")
2066             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
2067             .addAllErrors(new ArrayList<Error>())
2068             .setCreateTime(Timestamp.newBuilder().build())
2069             .setUpdateTime(Timestamp.newBuilder().build())
2070             .setLastRunTime(Timestamp.newBuilder().build())
2071             .build();
2072     mockDlpService.addResponse(expectedResponse);
2073 
2074     String parent = "parent-995424086";
2075     JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2076 
2077     JobTrigger actualResponse = client.createJobTrigger(parent, jobTrigger);
2078     Assert.assertEquals(expectedResponse, actualResponse);
2079 
2080     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2081     Assert.assertEquals(1, actualRequests.size());
2082     CreateJobTriggerRequest actualRequest = ((CreateJobTriggerRequest) actualRequests.get(0));
2083 
2084     Assert.assertEquals(parent, actualRequest.getParent());
2085     Assert.assertEquals(jobTrigger, actualRequest.getJobTrigger());
2086     Assert.assertTrue(
2087         channelProvider.isHeaderSent(
2088             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2089             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2090   }
2091 
2092   @Test
createJobTriggerExceptionTest3()2093   public void createJobTriggerExceptionTest3() throws Exception {
2094     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2095     mockDlpService.addException(exception);
2096 
2097     try {
2098       String parent = "parent-995424086";
2099       JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2100       client.createJobTrigger(parent, jobTrigger);
2101       Assert.fail("No exception raised");
2102     } catch (InvalidArgumentException e) {
2103       // Expected exception.
2104     }
2105   }
2106 
2107   @Test
updateJobTriggerTest()2108   public void updateJobTriggerTest() throws Exception {
2109     JobTrigger expectedResponse =
2110         JobTrigger.newBuilder()
2111             .setName(
2112                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2113             .setDisplayName("displayName1714148973")
2114             .setDescription("description-1724546052")
2115             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
2116             .addAllErrors(new ArrayList<Error>())
2117             .setCreateTime(Timestamp.newBuilder().build())
2118             .setUpdateTime(Timestamp.newBuilder().build())
2119             .setLastRunTime(Timestamp.newBuilder().build())
2120             .build();
2121     mockDlpService.addResponse(expectedResponse);
2122 
2123     JobTriggerName name = JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]");
2124     JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2125     FieldMask updateMask = FieldMask.newBuilder().build();
2126 
2127     JobTrigger actualResponse = client.updateJobTrigger(name, jobTrigger, updateMask);
2128     Assert.assertEquals(expectedResponse, actualResponse);
2129 
2130     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2131     Assert.assertEquals(1, actualRequests.size());
2132     UpdateJobTriggerRequest actualRequest = ((UpdateJobTriggerRequest) actualRequests.get(0));
2133 
2134     Assert.assertEquals(name.toString(), actualRequest.getName());
2135     Assert.assertEquals(jobTrigger, actualRequest.getJobTrigger());
2136     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
2137     Assert.assertTrue(
2138         channelProvider.isHeaderSent(
2139             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2140             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2141   }
2142 
2143   @Test
updateJobTriggerExceptionTest()2144   public void updateJobTriggerExceptionTest() throws Exception {
2145     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2146     mockDlpService.addException(exception);
2147 
2148     try {
2149       JobTriggerName name = JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]");
2150       JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2151       FieldMask updateMask = FieldMask.newBuilder().build();
2152       client.updateJobTrigger(name, jobTrigger, updateMask);
2153       Assert.fail("No exception raised");
2154     } catch (InvalidArgumentException e) {
2155       // Expected exception.
2156     }
2157   }
2158 
2159   @Test
updateJobTriggerTest2()2160   public void updateJobTriggerTest2() throws Exception {
2161     JobTrigger expectedResponse =
2162         JobTrigger.newBuilder()
2163             .setName(
2164                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2165             .setDisplayName("displayName1714148973")
2166             .setDescription("description-1724546052")
2167             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
2168             .addAllErrors(new ArrayList<Error>())
2169             .setCreateTime(Timestamp.newBuilder().build())
2170             .setUpdateTime(Timestamp.newBuilder().build())
2171             .setLastRunTime(Timestamp.newBuilder().build())
2172             .build();
2173     mockDlpService.addResponse(expectedResponse);
2174 
2175     String name = "name3373707";
2176     JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2177     FieldMask updateMask = FieldMask.newBuilder().build();
2178 
2179     JobTrigger actualResponse = client.updateJobTrigger(name, jobTrigger, updateMask);
2180     Assert.assertEquals(expectedResponse, actualResponse);
2181 
2182     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2183     Assert.assertEquals(1, actualRequests.size());
2184     UpdateJobTriggerRequest actualRequest = ((UpdateJobTriggerRequest) actualRequests.get(0));
2185 
2186     Assert.assertEquals(name, actualRequest.getName());
2187     Assert.assertEquals(jobTrigger, actualRequest.getJobTrigger());
2188     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
2189     Assert.assertTrue(
2190         channelProvider.isHeaderSent(
2191             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2192             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2193   }
2194 
2195   @Test
updateJobTriggerExceptionTest2()2196   public void updateJobTriggerExceptionTest2() throws Exception {
2197     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2198     mockDlpService.addException(exception);
2199 
2200     try {
2201       String name = "name3373707";
2202       JobTrigger jobTrigger = JobTrigger.newBuilder().build();
2203       FieldMask updateMask = FieldMask.newBuilder().build();
2204       client.updateJobTrigger(name, jobTrigger, updateMask);
2205       Assert.fail("No exception raised");
2206     } catch (InvalidArgumentException e) {
2207       // Expected exception.
2208     }
2209   }
2210 
2211   @Test
hybridInspectJobTriggerTest()2212   public void hybridInspectJobTriggerTest() throws Exception {
2213     HybridInspectResponse expectedResponse = HybridInspectResponse.newBuilder().build();
2214     mockDlpService.addResponse(expectedResponse);
2215 
2216     JobTriggerName name =
2217         JobTriggerName.ofProjectLocationJobTriggerName("[PROJECT]", "[LOCATION]", "[JOB_TRIGGER]");
2218 
2219     HybridInspectResponse actualResponse = client.hybridInspectJobTrigger(name);
2220     Assert.assertEquals(expectedResponse, actualResponse);
2221 
2222     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2223     Assert.assertEquals(1, actualRequests.size());
2224     HybridInspectJobTriggerRequest actualRequest =
2225         ((HybridInspectJobTriggerRequest) actualRequests.get(0));
2226 
2227     Assert.assertEquals(name.toString(), actualRequest.getName());
2228     Assert.assertTrue(
2229         channelProvider.isHeaderSent(
2230             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2231             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2232   }
2233 
2234   @Test
hybridInspectJobTriggerExceptionTest()2235   public void hybridInspectJobTriggerExceptionTest() throws Exception {
2236     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2237     mockDlpService.addException(exception);
2238 
2239     try {
2240       JobTriggerName name =
2241           JobTriggerName.ofProjectLocationJobTriggerName(
2242               "[PROJECT]", "[LOCATION]", "[JOB_TRIGGER]");
2243       client.hybridInspectJobTrigger(name);
2244       Assert.fail("No exception raised");
2245     } catch (InvalidArgumentException e) {
2246       // Expected exception.
2247     }
2248   }
2249 
2250   @Test
hybridInspectJobTriggerTest2()2251   public void hybridInspectJobTriggerTest2() throws Exception {
2252     HybridInspectResponse expectedResponse = HybridInspectResponse.newBuilder().build();
2253     mockDlpService.addResponse(expectedResponse);
2254 
2255     String name = "name3373707";
2256 
2257     HybridInspectResponse actualResponse = client.hybridInspectJobTrigger(name);
2258     Assert.assertEquals(expectedResponse, actualResponse);
2259 
2260     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2261     Assert.assertEquals(1, actualRequests.size());
2262     HybridInspectJobTriggerRequest actualRequest =
2263         ((HybridInspectJobTriggerRequest) actualRequests.get(0));
2264 
2265     Assert.assertEquals(name, actualRequest.getName());
2266     Assert.assertTrue(
2267         channelProvider.isHeaderSent(
2268             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2269             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2270   }
2271 
2272   @Test
hybridInspectJobTriggerExceptionTest2()2273   public void hybridInspectJobTriggerExceptionTest2() throws Exception {
2274     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2275     mockDlpService.addException(exception);
2276 
2277     try {
2278       String name = "name3373707";
2279       client.hybridInspectJobTrigger(name);
2280       Assert.fail("No exception raised");
2281     } catch (InvalidArgumentException e) {
2282       // Expected exception.
2283     }
2284   }
2285 
2286   @Test
getJobTriggerTest()2287   public void getJobTriggerTest() throws Exception {
2288     JobTrigger expectedResponse =
2289         JobTrigger.newBuilder()
2290             .setName(
2291                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2292             .setDisplayName("displayName1714148973")
2293             .setDescription("description-1724546052")
2294             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
2295             .addAllErrors(new ArrayList<Error>())
2296             .setCreateTime(Timestamp.newBuilder().build())
2297             .setUpdateTime(Timestamp.newBuilder().build())
2298             .setLastRunTime(Timestamp.newBuilder().build())
2299             .build();
2300     mockDlpService.addResponse(expectedResponse);
2301 
2302     JobTriggerName name = JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]");
2303 
2304     JobTrigger actualResponse = client.getJobTrigger(name);
2305     Assert.assertEquals(expectedResponse, actualResponse);
2306 
2307     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2308     Assert.assertEquals(1, actualRequests.size());
2309     GetJobTriggerRequest actualRequest = ((GetJobTriggerRequest) actualRequests.get(0));
2310 
2311     Assert.assertEquals(name.toString(), actualRequest.getName());
2312     Assert.assertTrue(
2313         channelProvider.isHeaderSent(
2314             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2315             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2316   }
2317 
2318   @Test
getJobTriggerExceptionTest()2319   public void getJobTriggerExceptionTest() throws Exception {
2320     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2321     mockDlpService.addException(exception);
2322 
2323     try {
2324       JobTriggerName name = JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]");
2325       client.getJobTrigger(name);
2326       Assert.fail("No exception raised");
2327     } catch (InvalidArgumentException e) {
2328       // Expected exception.
2329     }
2330   }
2331 
2332   @Test
getJobTriggerTest2()2333   public void getJobTriggerTest2() throws Exception {
2334     JobTrigger expectedResponse =
2335         JobTrigger.newBuilder()
2336             .setName(
2337                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2338             .setDisplayName("displayName1714148973")
2339             .setDescription("description-1724546052")
2340             .addAllTriggers(new ArrayList<JobTrigger.Trigger>())
2341             .addAllErrors(new ArrayList<Error>())
2342             .setCreateTime(Timestamp.newBuilder().build())
2343             .setUpdateTime(Timestamp.newBuilder().build())
2344             .setLastRunTime(Timestamp.newBuilder().build())
2345             .build();
2346     mockDlpService.addResponse(expectedResponse);
2347 
2348     String name = "name3373707";
2349 
2350     JobTrigger actualResponse = client.getJobTrigger(name);
2351     Assert.assertEquals(expectedResponse, actualResponse);
2352 
2353     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2354     Assert.assertEquals(1, actualRequests.size());
2355     GetJobTriggerRequest actualRequest = ((GetJobTriggerRequest) actualRequests.get(0));
2356 
2357     Assert.assertEquals(name, actualRequest.getName());
2358     Assert.assertTrue(
2359         channelProvider.isHeaderSent(
2360             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2361             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2362   }
2363 
2364   @Test
getJobTriggerExceptionTest2()2365   public void getJobTriggerExceptionTest2() throws Exception {
2366     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2367     mockDlpService.addException(exception);
2368 
2369     try {
2370       String name = "name3373707";
2371       client.getJobTrigger(name);
2372       Assert.fail("No exception raised");
2373     } catch (InvalidArgumentException e) {
2374       // Expected exception.
2375     }
2376   }
2377 
2378   @Test
listJobTriggersTest()2379   public void listJobTriggersTest() throws Exception {
2380     JobTrigger responsesElement = JobTrigger.newBuilder().build();
2381     ListJobTriggersResponse expectedResponse =
2382         ListJobTriggersResponse.newBuilder()
2383             .setNextPageToken("")
2384             .addAllJobTriggers(Arrays.asList(responsesElement))
2385             .build();
2386     mockDlpService.addResponse(expectedResponse);
2387 
2388     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2389 
2390     ListJobTriggersPagedResponse pagedListResponse = client.listJobTriggers(parent);
2391 
2392     List<JobTrigger> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2393 
2394     Assert.assertEquals(1, resources.size());
2395     Assert.assertEquals(expectedResponse.getJobTriggersList().get(0), resources.get(0));
2396 
2397     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2398     Assert.assertEquals(1, actualRequests.size());
2399     ListJobTriggersRequest actualRequest = ((ListJobTriggersRequest) actualRequests.get(0));
2400 
2401     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2402     Assert.assertTrue(
2403         channelProvider.isHeaderSent(
2404             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2405             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2406   }
2407 
2408   @Test
listJobTriggersExceptionTest()2409   public void listJobTriggersExceptionTest() throws Exception {
2410     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2411     mockDlpService.addException(exception);
2412 
2413     try {
2414       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2415       client.listJobTriggers(parent);
2416       Assert.fail("No exception raised");
2417     } catch (InvalidArgumentException e) {
2418       // Expected exception.
2419     }
2420   }
2421 
2422   @Test
listJobTriggersTest2()2423   public void listJobTriggersTest2() throws Exception {
2424     JobTrigger responsesElement = JobTrigger.newBuilder().build();
2425     ListJobTriggersResponse expectedResponse =
2426         ListJobTriggersResponse.newBuilder()
2427             .setNextPageToken("")
2428             .addAllJobTriggers(Arrays.asList(responsesElement))
2429             .build();
2430     mockDlpService.addResponse(expectedResponse);
2431 
2432     ProjectName parent = ProjectName.of("[PROJECT]");
2433 
2434     ListJobTriggersPagedResponse pagedListResponse = client.listJobTriggers(parent);
2435 
2436     List<JobTrigger> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2437 
2438     Assert.assertEquals(1, resources.size());
2439     Assert.assertEquals(expectedResponse.getJobTriggersList().get(0), resources.get(0));
2440 
2441     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2442     Assert.assertEquals(1, actualRequests.size());
2443     ListJobTriggersRequest actualRequest = ((ListJobTriggersRequest) actualRequests.get(0));
2444 
2445     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2446     Assert.assertTrue(
2447         channelProvider.isHeaderSent(
2448             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2449             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2450   }
2451 
2452   @Test
listJobTriggersExceptionTest2()2453   public void listJobTriggersExceptionTest2() throws Exception {
2454     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2455     mockDlpService.addException(exception);
2456 
2457     try {
2458       ProjectName parent = ProjectName.of("[PROJECT]");
2459       client.listJobTriggers(parent);
2460       Assert.fail("No exception raised");
2461     } catch (InvalidArgumentException e) {
2462       // Expected exception.
2463     }
2464   }
2465 
2466   @Test
listJobTriggersTest3()2467   public void listJobTriggersTest3() throws Exception {
2468     JobTrigger responsesElement = JobTrigger.newBuilder().build();
2469     ListJobTriggersResponse expectedResponse =
2470         ListJobTriggersResponse.newBuilder()
2471             .setNextPageToken("")
2472             .addAllJobTriggers(Arrays.asList(responsesElement))
2473             .build();
2474     mockDlpService.addResponse(expectedResponse);
2475 
2476     String parent = "parent-995424086";
2477 
2478     ListJobTriggersPagedResponse pagedListResponse = client.listJobTriggers(parent);
2479 
2480     List<JobTrigger> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2481 
2482     Assert.assertEquals(1, resources.size());
2483     Assert.assertEquals(expectedResponse.getJobTriggersList().get(0), resources.get(0));
2484 
2485     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2486     Assert.assertEquals(1, actualRequests.size());
2487     ListJobTriggersRequest actualRequest = ((ListJobTriggersRequest) actualRequests.get(0));
2488 
2489     Assert.assertEquals(parent, actualRequest.getParent());
2490     Assert.assertTrue(
2491         channelProvider.isHeaderSent(
2492             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2493             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2494   }
2495 
2496   @Test
listJobTriggersExceptionTest3()2497   public void listJobTriggersExceptionTest3() throws Exception {
2498     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2499     mockDlpService.addException(exception);
2500 
2501     try {
2502       String parent = "parent-995424086";
2503       client.listJobTriggers(parent);
2504       Assert.fail("No exception raised");
2505     } catch (InvalidArgumentException e) {
2506       // Expected exception.
2507     }
2508   }
2509 
2510   @Test
deleteJobTriggerTest()2511   public void deleteJobTriggerTest() throws Exception {
2512     Empty expectedResponse = Empty.newBuilder().build();
2513     mockDlpService.addResponse(expectedResponse);
2514 
2515     JobTriggerName name = JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]");
2516 
2517     client.deleteJobTrigger(name);
2518 
2519     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2520     Assert.assertEquals(1, actualRequests.size());
2521     DeleteJobTriggerRequest actualRequest = ((DeleteJobTriggerRequest) actualRequests.get(0));
2522 
2523     Assert.assertEquals(name.toString(), actualRequest.getName());
2524     Assert.assertTrue(
2525         channelProvider.isHeaderSent(
2526             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2527             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2528   }
2529 
2530   @Test
deleteJobTriggerExceptionTest()2531   public void deleteJobTriggerExceptionTest() throws Exception {
2532     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2533     mockDlpService.addException(exception);
2534 
2535     try {
2536       JobTriggerName name = JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]");
2537       client.deleteJobTrigger(name);
2538       Assert.fail("No exception raised");
2539     } catch (InvalidArgumentException e) {
2540       // Expected exception.
2541     }
2542   }
2543 
2544   @Test
deleteJobTriggerTest2()2545   public void deleteJobTriggerTest2() throws Exception {
2546     Empty expectedResponse = Empty.newBuilder().build();
2547     mockDlpService.addResponse(expectedResponse);
2548 
2549     String name = "name3373707";
2550 
2551     client.deleteJobTrigger(name);
2552 
2553     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2554     Assert.assertEquals(1, actualRequests.size());
2555     DeleteJobTriggerRequest actualRequest = ((DeleteJobTriggerRequest) actualRequests.get(0));
2556 
2557     Assert.assertEquals(name, actualRequest.getName());
2558     Assert.assertTrue(
2559         channelProvider.isHeaderSent(
2560             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2561             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2562   }
2563 
2564   @Test
deleteJobTriggerExceptionTest2()2565   public void deleteJobTriggerExceptionTest2() throws Exception {
2566     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2567     mockDlpService.addException(exception);
2568 
2569     try {
2570       String name = "name3373707";
2571       client.deleteJobTrigger(name);
2572       Assert.fail("No exception raised");
2573     } catch (InvalidArgumentException e) {
2574       // Expected exception.
2575     }
2576   }
2577 
2578   @Test
activateJobTriggerTest()2579   public void activateJobTriggerTest() throws Exception {
2580     DlpJob expectedResponse =
2581         DlpJob.newBuilder()
2582             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2583             .setType(DlpJobType.forNumber(0))
2584             .setCreateTime(Timestamp.newBuilder().build())
2585             .setStartTime(Timestamp.newBuilder().build())
2586             .setEndTime(Timestamp.newBuilder().build())
2587             .setJobTriggerName("jobTriggerName494333030")
2588             .addAllErrors(new ArrayList<Error>())
2589             .build();
2590     mockDlpService.addResponse(expectedResponse);
2591 
2592     ActivateJobTriggerRequest request =
2593         ActivateJobTriggerRequest.newBuilder()
2594             .setName(
2595                 JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2596             .build();
2597 
2598     DlpJob actualResponse = client.activateJobTrigger(request);
2599     Assert.assertEquals(expectedResponse, actualResponse);
2600 
2601     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2602     Assert.assertEquals(1, actualRequests.size());
2603     ActivateJobTriggerRequest actualRequest = ((ActivateJobTriggerRequest) actualRequests.get(0));
2604 
2605     Assert.assertEquals(request.getName(), actualRequest.getName());
2606     Assert.assertTrue(
2607         channelProvider.isHeaderSent(
2608             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2609             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2610   }
2611 
2612   @Test
activateJobTriggerExceptionTest()2613   public void activateJobTriggerExceptionTest() throws Exception {
2614     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2615     mockDlpService.addException(exception);
2616 
2617     try {
2618       ActivateJobTriggerRequest request =
2619           ActivateJobTriggerRequest.newBuilder()
2620               .setName(
2621                   JobTriggerName.ofProjectJobTriggerName("[PROJECT]", "[JOB_TRIGGER]").toString())
2622               .build();
2623       client.activateJobTrigger(request);
2624       Assert.fail("No exception raised");
2625     } catch (InvalidArgumentException e) {
2626       // Expected exception.
2627     }
2628   }
2629 
2630   @Test
createDlpJobTest()2631   public void createDlpJobTest() throws Exception {
2632     DlpJob expectedResponse =
2633         DlpJob.newBuilder()
2634             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2635             .setType(DlpJobType.forNumber(0))
2636             .setCreateTime(Timestamp.newBuilder().build())
2637             .setStartTime(Timestamp.newBuilder().build())
2638             .setEndTime(Timestamp.newBuilder().build())
2639             .setJobTriggerName("jobTriggerName494333030")
2640             .addAllErrors(new ArrayList<Error>())
2641             .build();
2642     mockDlpService.addResponse(expectedResponse);
2643 
2644     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2645     InspectJobConfig inspectJob = InspectJobConfig.newBuilder().build();
2646 
2647     DlpJob actualResponse = client.createDlpJob(parent, inspectJob);
2648     Assert.assertEquals(expectedResponse, actualResponse);
2649 
2650     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2651     Assert.assertEquals(1, actualRequests.size());
2652     CreateDlpJobRequest actualRequest = ((CreateDlpJobRequest) actualRequests.get(0));
2653 
2654     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2655     Assert.assertEquals(inspectJob, actualRequest.getInspectJob());
2656     Assert.assertTrue(
2657         channelProvider.isHeaderSent(
2658             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2659             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2660   }
2661 
2662   @Test
createDlpJobExceptionTest()2663   public void createDlpJobExceptionTest() throws Exception {
2664     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2665     mockDlpService.addException(exception);
2666 
2667     try {
2668       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2669       InspectJobConfig inspectJob = InspectJobConfig.newBuilder().build();
2670       client.createDlpJob(parent, inspectJob);
2671       Assert.fail("No exception raised");
2672     } catch (InvalidArgumentException e) {
2673       // Expected exception.
2674     }
2675   }
2676 
2677   @Test
createDlpJobTest2()2678   public void createDlpJobTest2() throws Exception {
2679     DlpJob expectedResponse =
2680         DlpJob.newBuilder()
2681             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2682             .setType(DlpJobType.forNumber(0))
2683             .setCreateTime(Timestamp.newBuilder().build())
2684             .setStartTime(Timestamp.newBuilder().build())
2685             .setEndTime(Timestamp.newBuilder().build())
2686             .setJobTriggerName("jobTriggerName494333030")
2687             .addAllErrors(new ArrayList<Error>())
2688             .build();
2689     mockDlpService.addResponse(expectedResponse);
2690 
2691     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2692     RiskAnalysisJobConfig riskJob = RiskAnalysisJobConfig.newBuilder().build();
2693 
2694     DlpJob actualResponse = client.createDlpJob(parent, riskJob);
2695     Assert.assertEquals(expectedResponse, actualResponse);
2696 
2697     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2698     Assert.assertEquals(1, actualRequests.size());
2699     CreateDlpJobRequest actualRequest = ((CreateDlpJobRequest) actualRequests.get(0));
2700 
2701     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2702     Assert.assertEquals(riskJob, actualRequest.getRiskJob());
2703     Assert.assertTrue(
2704         channelProvider.isHeaderSent(
2705             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2706             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2707   }
2708 
2709   @Test
createDlpJobExceptionTest2()2710   public void createDlpJobExceptionTest2() throws Exception {
2711     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2712     mockDlpService.addException(exception);
2713 
2714     try {
2715       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2716       RiskAnalysisJobConfig riskJob = RiskAnalysisJobConfig.newBuilder().build();
2717       client.createDlpJob(parent, riskJob);
2718       Assert.fail("No exception raised");
2719     } catch (InvalidArgumentException e) {
2720       // Expected exception.
2721     }
2722   }
2723 
2724   @Test
createDlpJobTest3()2725   public void createDlpJobTest3() throws Exception {
2726     DlpJob expectedResponse =
2727         DlpJob.newBuilder()
2728             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2729             .setType(DlpJobType.forNumber(0))
2730             .setCreateTime(Timestamp.newBuilder().build())
2731             .setStartTime(Timestamp.newBuilder().build())
2732             .setEndTime(Timestamp.newBuilder().build())
2733             .setJobTriggerName("jobTriggerName494333030")
2734             .addAllErrors(new ArrayList<Error>())
2735             .build();
2736     mockDlpService.addResponse(expectedResponse);
2737 
2738     ProjectName parent = ProjectName.of("[PROJECT]");
2739     InspectJobConfig inspectJob = InspectJobConfig.newBuilder().build();
2740 
2741     DlpJob actualResponse = client.createDlpJob(parent, inspectJob);
2742     Assert.assertEquals(expectedResponse, actualResponse);
2743 
2744     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2745     Assert.assertEquals(1, actualRequests.size());
2746     CreateDlpJobRequest actualRequest = ((CreateDlpJobRequest) actualRequests.get(0));
2747 
2748     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2749     Assert.assertEquals(inspectJob, actualRequest.getInspectJob());
2750     Assert.assertTrue(
2751         channelProvider.isHeaderSent(
2752             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2753             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2754   }
2755 
2756   @Test
createDlpJobExceptionTest3()2757   public void createDlpJobExceptionTest3() throws Exception {
2758     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2759     mockDlpService.addException(exception);
2760 
2761     try {
2762       ProjectName parent = ProjectName.of("[PROJECT]");
2763       InspectJobConfig inspectJob = InspectJobConfig.newBuilder().build();
2764       client.createDlpJob(parent, inspectJob);
2765       Assert.fail("No exception raised");
2766     } catch (InvalidArgumentException e) {
2767       // Expected exception.
2768     }
2769   }
2770 
2771   @Test
createDlpJobTest4()2772   public void createDlpJobTest4() throws Exception {
2773     DlpJob expectedResponse =
2774         DlpJob.newBuilder()
2775             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2776             .setType(DlpJobType.forNumber(0))
2777             .setCreateTime(Timestamp.newBuilder().build())
2778             .setStartTime(Timestamp.newBuilder().build())
2779             .setEndTime(Timestamp.newBuilder().build())
2780             .setJobTriggerName("jobTriggerName494333030")
2781             .addAllErrors(new ArrayList<Error>())
2782             .build();
2783     mockDlpService.addResponse(expectedResponse);
2784 
2785     ProjectName parent = ProjectName.of("[PROJECT]");
2786     RiskAnalysisJobConfig riskJob = RiskAnalysisJobConfig.newBuilder().build();
2787 
2788     DlpJob actualResponse = client.createDlpJob(parent, riskJob);
2789     Assert.assertEquals(expectedResponse, actualResponse);
2790 
2791     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2792     Assert.assertEquals(1, actualRequests.size());
2793     CreateDlpJobRequest actualRequest = ((CreateDlpJobRequest) actualRequests.get(0));
2794 
2795     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2796     Assert.assertEquals(riskJob, actualRequest.getRiskJob());
2797     Assert.assertTrue(
2798         channelProvider.isHeaderSent(
2799             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2800             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2801   }
2802 
2803   @Test
createDlpJobExceptionTest4()2804   public void createDlpJobExceptionTest4() throws Exception {
2805     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2806     mockDlpService.addException(exception);
2807 
2808     try {
2809       ProjectName parent = ProjectName.of("[PROJECT]");
2810       RiskAnalysisJobConfig riskJob = RiskAnalysisJobConfig.newBuilder().build();
2811       client.createDlpJob(parent, riskJob);
2812       Assert.fail("No exception raised");
2813     } catch (InvalidArgumentException e) {
2814       // Expected exception.
2815     }
2816   }
2817 
2818   @Test
createDlpJobTest5()2819   public void createDlpJobTest5() throws Exception {
2820     DlpJob expectedResponse =
2821         DlpJob.newBuilder()
2822             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2823             .setType(DlpJobType.forNumber(0))
2824             .setCreateTime(Timestamp.newBuilder().build())
2825             .setStartTime(Timestamp.newBuilder().build())
2826             .setEndTime(Timestamp.newBuilder().build())
2827             .setJobTriggerName("jobTriggerName494333030")
2828             .addAllErrors(new ArrayList<Error>())
2829             .build();
2830     mockDlpService.addResponse(expectedResponse);
2831 
2832     String parent = "parent-995424086";
2833     InspectJobConfig inspectJob = InspectJobConfig.newBuilder().build();
2834 
2835     DlpJob actualResponse = client.createDlpJob(parent, inspectJob);
2836     Assert.assertEquals(expectedResponse, actualResponse);
2837 
2838     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2839     Assert.assertEquals(1, actualRequests.size());
2840     CreateDlpJobRequest actualRequest = ((CreateDlpJobRequest) actualRequests.get(0));
2841 
2842     Assert.assertEquals(parent, actualRequest.getParent());
2843     Assert.assertEquals(inspectJob, actualRequest.getInspectJob());
2844     Assert.assertTrue(
2845         channelProvider.isHeaderSent(
2846             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2847             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2848   }
2849 
2850   @Test
createDlpJobExceptionTest5()2851   public void createDlpJobExceptionTest5() throws Exception {
2852     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2853     mockDlpService.addException(exception);
2854 
2855     try {
2856       String parent = "parent-995424086";
2857       InspectJobConfig inspectJob = InspectJobConfig.newBuilder().build();
2858       client.createDlpJob(parent, inspectJob);
2859       Assert.fail("No exception raised");
2860     } catch (InvalidArgumentException e) {
2861       // Expected exception.
2862     }
2863   }
2864 
2865   @Test
createDlpJobTest6()2866   public void createDlpJobTest6() throws Exception {
2867     DlpJob expectedResponse =
2868         DlpJob.newBuilder()
2869             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
2870             .setType(DlpJobType.forNumber(0))
2871             .setCreateTime(Timestamp.newBuilder().build())
2872             .setStartTime(Timestamp.newBuilder().build())
2873             .setEndTime(Timestamp.newBuilder().build())
2874             .setJobTriggerName("jobTriggerName494333030")
2875             .addAllErrors(new ArrayList<Error>())
2876             .build();
2877     mockDlpService.addResponse(expectedResponse);
2878 
2879     String parent = "parent-995424086";
2880     RiskAnalysisJobConfig riskJob = RiskAnalysisJobConfig.newBuilder().build();
2881 
2882     DlpJob actualResponse = client.createDlpJob(parent, riskJob);
2883     Assert.assertEquals(expectedResponse, actualResponse);
2884 
2885     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2886     Assert.assertEquals(1, actualRequests.size());
2887     CreateDlpJobRequest actualRequest = ((CreateDlpJobRequest) actualRequests.get(0));
2888 
2889     Assert.assertEquals(parent, actualRequest.getParent());
2890     Assert.assertEquals(riskJob, actualRequest.getRiskJob());
2891     Assert.assertTrue(
2892         channelProvider.isHeaderSent(
2893             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2894             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2895   }
2896 
2897   @Test
createDlpJobExceptionTest6()2898   public void createDlpJobExceptionTest6() throws Exception {
2899     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2900     mockDlpService.addException(exception);
2901 
2902     try {
2903       String parent = "parent-995424086";
2904       RiskAnalysisJobConfig riskJob = RiskAnalysisJobConfig.newBuilder().build();
2905       client.createDlpJob(parent, riskJob);
2906       Assert.fail("No exception raised");
2907     } catch (InvalidArgumentException e) {
2908       // Expected exception.
2909     }
2910   }
2911 
2912   @Test
listDlpJobsTest()2913   public void listDlpJobsTest() throws Exception {
2914     DlpJob responsesElement = DlpJob.newBuilder().build();
2915     ListDlpJobsResponse expectedResponse =
2916         ListDlpJobsResponse.newBuilder()
2917             .setNextPageToken("")
2918             .addAllJobs(Arrays.asList(responsesElement))
2919             .build();
2920     mockDlpService.addResponse(expectedResponse);
2921 
2922     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2923 
2924     ListDlpJobsPagedResponse pagedListResponse = client.listDlpJobs(parent);
2925 
2926     List<DlpJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2927 
2928     Assert.assertEquals(1, resources.size());
2929     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
2930 
2931     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2932     Assert.assertEquals(1, actualRequests.size());
2933     ListDlpJobsRequest actualRequest = ((ListDlpJobsRequest) actualRequests.get(0));
2934 
2935     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2936     Assert.assertTrue(
2937         channelProvider.isHeaderSent(
2938             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2939             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2940   }
2941 
2942   @Test
listDlpJobsExceptionTest()2943   public void listDlpJobsExceptionTest() throws Exception {
2944     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2945     mockDlpService.addException(exception);
2946 
2947     try {
2948       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2949       client.listDlpJobs(parent);
2950       Assert.fail("No exception raised");
2951     } catch (InvalidArgumentException e) {
2952       // Expected exception.
2953     }
2954   }
2955 
2956   @Test
listDlpJobsTest2()2957   public void listDlpJobsTest2() throws Exception {
2958     DlpJob responsesElement = DlpJob.newBuilder().build();
2959     ListDlpJobsResponse expectedResponse =
2960         ListDlpJobsResponse.newBuilder()
2961             .setNextPageToken("")
2962             .addAllJobs(Arrays.asList(responsesElement))
2963             .build();
2964     mockDlpService.addResponse(expectedResponse);
2965 
2966     ProjectName parent = ProjectName.of("[PROJECT]");
2967 
2968     ListDlpJobsPagedResponse pagedListResponse = client.listDlpJobs(parent);
2969 
2970     List<DlpJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2971 
2972     Assert.assertEquals(1, resources.size());
2973     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
2974 
2975     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
2976     Assert.assertEquals(1, actualRequests.size());
2977     ListDlpJobsRequest actualRequest = ((ListDlpJobsRequest) actualRequests.get(0));
2978 
2979     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2980     Assert.assertTrue(
2981         channelProvider.isHeaderSent(
2982             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2983             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2984   }
2985 
2986   @Test
listDlpJobsExceptionTest2()2987   public void listDlpJobsExceptionTest2() throws Exception {
2988     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2989     mockDlpService.addException(exception);
2990 
2991     try {
2992       ProjectName parent = ProjectName.of("[PROJECT]");
2993       client.listDlpJobs(parent);
2994       Assert.fail("No exception raised");
2995     } catch (InvalidArgumentException e) {
2996       // Expected exception.
2997     }
2998   }
2999 
3000   @Test
listDlpJobsTest3()3001   public void listDlpJobsTest3() throws Exception {
3002     DlpJob responsesElement = DlpJob.newBuilder().build();
3003     ListDlpJobsResponse expectedResponse =
3004         ListDlpJobsResponse.newBuilder()
3005             .setNextPageToken("")
3006             .addAllJobs(Arrays.asList(responsesElement))
3007             .build();
3008     mockDlpService.addResponse(expectedResponse);
3009 
3010     String parent = "parent-995424086";
3011 
3012     ListDlpJobsPagedResponse pagedListResponse = client.listDlpJobs(parent);
3013 
3014     List<DlpJob> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3015 
3016     Assert.assertEquals(1, resources.size());
3017     Assert.assertEquals(expectedResponse.getJobsList().get(0), resources.get(0));
3018 
3019     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3020     Assert.assertEquals(1, actualRequests.size());
3021     ListDlpJobsRequest actualRequest = ((ListDlpJobsRequest) actualRequests.get(0));
3022 
3023     Assert.assertEquals(parent, actualRequest.getParent());
3024     Assert.assertTrue(
3025         channelProvider.isHeaderSent(
3026             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3027             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3028   }
3029 
3030   @Test
listDlpJobsExceptionTest3()3031   public void listDlpJobsExceptionTest3() throws Exception {
3032     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3033     mockDlpService.addException(exception);
3034 
3035     try {
3036       String parent = "parent-995424086";
3037       client.listDlpJobs(parent);
3038       Assert.fail("No exception raised");
3039     } catch (InvalidArgumentException e) {
3040       // Expected exception.
3041     }
3042   }
3043 
3044   @Test
getDlpJobTest()3045   public void getDlpJobTest() throws Exception {
3046     DlpJob expectedResponse =
3047         DlpJob.newBuilder()
3048             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
3049             .setType(DlpJobType.forNumber(0))
3050             .setCreateTime(Timestamp.newBuilder().build())
3051             .setStartTime(Timestamp.newBuilder().build())
3052             .setEndTime(Timestamp.newBuilder().build())
3053             .setJobTriggerName("jobTriggerName494333030")
3054             .addAllErrors(new ArrayList<Error>())
3055             .build();
3056     mockDlpService.addResponse(expectedResponse);
3057 
3058     DlpJobName name = DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]");
3059 
3060     DlpJob actualResponse = client.getDlpJob(name);
3061     Assert.assertEquals(expectedResponse, actualResponse);
3062 
3063     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3064     Assert.assertEquals(1, actualRequests.size());
3065     GetDlpJobRequest actualRequest = ((GetDlpJobRequest) actualRequests.get(0));
3066 
3067     Assert.assertEquals(name.toString(), actualRequest.getName());
3068     Assert.assertTrue(
3069         channelProvider.isHeaderSent(
3070             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3071             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3072   }
3073 
3074   @Test
getDlpJobExceptionTest()3075   public void getDlpJobExceptionTest() throws Exception {
3076     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3077     mockDlpService.addException(exception);
3078 
3079     try {
3080       DlpJobName name = DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]");
3081       client.getDlpJob(name);
3082       Assert.fail("No exception raised");
3083     } catch (InvalidArgumentException e) {
3084       // Expected exception.
3085     }
3086   }
3087 
3088   @Test
getDlpJobTest2()3089   public void getDlpJobTest2() throws Exception {
3090     DlpJob expectedResponse =
3091         DlpJob.newBuilder()
3092             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
3093             .setType(DlpJobType.forNumber(0))
3094             .setCreateTime(Timestamp.newBuilder().build())
3095             .setStartTime(Timestamp.newBuilder().build())
3096             .setEndTime(Timestamp.newBuilder().build())
3097             .setJobTriggerName("jobTriggerName494333030")
3098             .addAllErrors(new ArrayList<Error>())
3099             .build();
3100     mockDlpService.addResponse(expectedResponse);
3101 
3102     String name = "name3373707";
3103 
3104     DlpJob actualResponse = client.getDlpJob(name);
3105     Assert.assertEquals(expectedResponse, actualResponse);
3106 
3107     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3108     Assert.assertEquals(1, actualRequests.size());
3109     GetDlpJobRequest actualRequest = ((GetDlpJobRequest) actualRequests.get(0));
3110 
3111     Assert.assertEquals(name, actualRequest.getName());
3112     Assert.assertTrue(
3113         channelProvider.isHeaderSent(
3114             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3115             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3116   }
3117 
3118   @Test
getDlpJobExceptionTest2()3119   public void getDlpJobExceptionTest2() throws Exception {
3120     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3121     mockDlpService.addException(exception);
3122 
3123     try {
3124       String name = "name3373707";
3125       client.getDlpJob(name);
3126       Assert.fail("No exception raised");
3127     } catch (InvalidArgumentException e) {
3128       // Expected exception.
3129     }
3130   }
3131 
3132   @Test
deleteDlpJobTest()3133   public void deleteDlpJobTest() throws Exception {
3134     Empty expectedResponse = Empty.newBuilder().build();
3135     mockDlpService.addResponse(expectedResponse);
3136 
3137     DlpJobName name = DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]");
3138 
3139     client.deleteDlpJob(name);
3140 
3141     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3142     Assert.assertEquals(1, actualRequests.size());
3143     DeleteDlpJobRequest actualRequest = ((DeleteDlpJobRequest) actualRequests.get(0));
3144 
3145     Assert.assertEquals(name.toString(), actualRequest.getName());
3146     Assert.assertTrue(
3147         channelProvider.isHeaderSent(
3148             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3149             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3150   }
3151 
3152   @Test
deleteDlpJobExceptionTest()3153   public void deleteDlpJobExceptionTest() throws Exception {
3154     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3155     mockDlpService.addException(exception);
3156 
3157     try {
3158       DlpJobName name = DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]");
3159       client.deleteDlpJob(name);
3160       Assert.fail("No exception raised");
3161     } catch (InvalidArgumentException e) {
3162       // Expected exception.
3163     }
3164   }
3165 
3166   @Test
deleteDlpJobTest2()3167   public void deleteDlpJobTest2() throws Exception {
3168     Empty expectedResponse = Empty.newBuilder().build();
3169     mockDlpService.addResponse(expectedResponse);
3170 
3171     String name = "name3373707";
3172 
3173     client.deleteDlpJob(name);
3174 
3175     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3176     Assert.assertEquals(1, actualRequests.size());
3177     DeleteDlpJobRequest actualRequest = ((DeleteDlpJobRequest) actualRequests.get(0));
3178 
3179     Assert.assertEquals(name, actualRequest.getName());
3180     Assert.assertTrue(
3181         channelProvider.isHeaderSent(
3182             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3183             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3184   }
3185 
3186   @Test
deleteDlpJobExceptionTest2()3187   public void deleteDlpJobExceptionTest2() throws Exception {
3188     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3189     mockDlpService.addException(exception);
3190 
3191     try {
3192       String name = "name3373707";
3193       client.deleteDlpJob(name);
3194       Assert.fail("No exception raised");
3195     } catch (InvalidArgumentException e) {
3196       // Expected exception.
3197     }
3198   }
3199 
3200   @Test
cancelDlpJobTest()3201   public void cancelDlpJobTest() throws Exception {
3202     Empty expectedResponse = Empty.newBuilder().build();
3203     mockDlpService.addResponse(expectedResponse);
3204 
3205     CancelDlpJobRequest request =
3206         CancelDlpJobRequest.newBuilder()
3207             .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
3208             .build();
3209 
3210     client.cancelDlpJob(request);
3211 
3212     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3213     Assert.assertEquals(1, actualRequests.size());
3214     CancelDlpJobRequest actualRequest = ((CancelDlpJobRequest) actualRequests.get(0));
3215 
3216     Assert.assertEquals(request.getName(), actualRequest.getName());
3217     Assert.assertTrue(
3218         channelProvider.isHeaderSent(
3219             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3220             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3221   }
3222 
3223   @Test
cancelDlpJobExceptionTest()3224   public void cancelDlpJobExceptionTest() throws Exception {
3225     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3226     mockDlpService.addException(exception);
3227 
3228     try {
3229       CancelDlpJobRequest request =
3230           CancelDlpJobRequest.newBuilder()
3231               .setName(DlpJobName.ofProjectDlpJobName("[PROJECT]", "[DLP_JOB]").toString())
3232               .build();
3233       client.cancelDlpJob(request);
3234       Assert.fail("No exception raised");
3235     } catch (InvalidArgumentException e) {
3236       // Expected exception.
3237     }
3238   }
3239 
3240   @Test
createStoredInfoTypeTest()3241   public void createStoredInfoTypeTest() throws Exception {
3242     StoredInfoType expectedResponse =
3243         StoredInfoType.newBuilder()
3244             .setName(
3245                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3246                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3247                     .toString())
3248             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3249             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3250             .build();
3251     mockDlpService.addResponse(expectedResponse);
3252 
3253     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3254     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3255 
3256     StoredInfoType actualResponse = client.createStoredInfoType(parent, config);
3257     Assert.assertEquals(expectedResponse, actualResponse);
3258 
3259     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3260     Assert.assertEquals(1, actualRequests.size());
3261     CreateStoredInfoTypeRequest actualRequest =
3262         ((CreateStoredInfoTypeRequest) actualRequests.get(0));
3263 
3264     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3265     Assert.assertEquals(config, actualRequest.getConfig());
3266     Assert.assertTrue(
3267         channelProvider.isHeaderSent(
3268             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3269             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3270   }
3271 
3272   @Test
createStoredInfoTypeExceptionTest()3273   public void createStoredInfoTypeExceptionTest() throws Exception {
3274     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3275     mockDlpService.addException(exception);
3276 
3277     try {
3278       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3279       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3280       client.createStoredInfoType(parent, config);
3281       Assert.fail("No exception raised");
3282     } catch (InvalidArgumentException e) {
3283       // Expected exception.
3284     }
3285   }
3286 
3287   @Test
createStoredInfoTypeTest2()3288   public void createStoredInfoTypeTest2() throws Exception {
3289     StoredInfoType expectedResponse =
3290         StoredInfoType.newBuilder()
3291             .setName(
3292                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3293                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3294                     .toString())
3295             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3296             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3297             .build();
3298     mockDlpService.addResponse(expectedResponse);
3299 
3300     OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
3301     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3302 
3303     StoredInfoType actualResponse = client.createStoredInfoType(parent, config);
3304     Assert.assertEquals(expectedResponse, actualResponse);
3305 
3306     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3307     Assert.assertEquals(1, actualRequests.size());
3308     CreateStoredInfoTypeRequest actualRequest =
3309         ((CreateStoredInfoTypeRequest) actualRequests.get(0));
3310 
3311     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3312     Assert.assertEquals(config, actualRequest.getConfig());
3313     Assert.assertTrue(
3314         channelProvider.isHeaderSent(
3315             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3316             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3317   }
3318 
3319   @Test
createStoredInfoTypeExceptionTest2()3320   public void createStoredInfoTypeExceptionTest2() throws Exception {
3321     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3322     mockDlpService.addException(exception);
3323 
3324     try {
3325       OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
3326       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3327       client.createStoredInfoType(parent, config);
3328       Assert.fail("No exception raised");
3329     } catch (InvalidArgumentException e) {
3330       // Expected exception.
3331     }
3332   }
3333 
3334   @Test
createStoredInfoTypeTest3()3335   public void createStoredInfoTypeTest3() throws Exception {
3336     StoredInfoType expectedResponse =
3337         StoredInfoType.newBuilder()
3338             .setName(
3339                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3340                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3341                     .toString())
3342             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3343             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3344             .build();
3345     mockDlpService.addResponse(expectedResponse);
3346 
3347     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
3348     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3349 
3350     StoredInfoType actualResponse = client.createStoredInfoType(parent, config);
3351     Assert.assertEquals(expectedResponse, actualResponse);
3352 
3353     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3354     Assert.assertEquals(1, actualRequests.size());
3355     CreateStoredInfoTypeRequest actualRequest =
3356         ((CreateStoredInfoTypeRequest) actualRequests.get(0));
3357 
3358     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3359     Assert.assertEquals(config, actualRequest.getConfig());
3360     Assert.assertTrue(
3361         channelProvider.isHeaderSent(
3362             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3363             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3364   }
3365 
3366   @Test
createStoredInfoTypeExceptionTest3()3367   public void createStoredInfoTypeExceptionTest3() throws Exception {
3368     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3369     mockDlpService.addException(exception);
3370 
3371     try {
3372       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
3373       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3374       client.createStoredInfoType(parent, config);
3375       Assert.fail("No exception raised");
3376     } catch (InvalidArgumentException e) {
3377       // Expected exception.
3378     }
3379   }
3380 
3381   @Test
createStoredInfoTypeTest4()3382   public void createStoredInfoTypeTest4() throws Exception {
3383     StoredInfoType expectedResponse =
3384         StoredInfoType.newBuilder()
3385             .setName(
3386                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3387                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3388                     .toString())
3389             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3390             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3391             .build();
3392     mockDlpService.addResponse(expectedResponse);
3393 
3394     ProjectName parent = ProjectName.of("[PROJECT]");
3395     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3396 
3397     StoredInfoType actualResponse = client.createStoredInfoType(parent, config);
3398     Assert.assertEquals(expectedResponse, actualResponse);
3399 
3400     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3401     Assert.assertEquals(1, actualRequests.size());
3402     CreateStoredInfoTypeRequest actualRequest =
3403         ((CreateStoredInfoTypeRequest) actualRequests.get(0));
3404 
3405     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3406     Assert.assertEquals(config, actualRequest.getConfig());
3407     Assert.assertTrue(
3408         channelProvider.isHeaderSent(
3409             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3410             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3411   }
3412 
3413   @Test
createStoredInfoTypeExceptionTest4()3414   public void createStoredInfoTypeExceptionTest4() throws Exception {
3415     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3416     mockDlpService.addException(exception);
3417 
3418     try {
3419       ProjectName parent = ProjectName.of("[PROJECT]");
3420       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3421       client.createStoredInfoType(parent, config);
3422       Assert.fail("No exception raised");
3423     } catch (InvalidArgumentException e) {
3424       // Expected exception.
3425     }
3426   }
3427 
3428   @Test
createStoredInfoTypeTest5()3429   public void createStoredInfoTypeTest5() throws Exception {
3430     StoredInfoType expectedResponse =
3431         StoredInfoType.newBuilder()
3432             .setName(
3433                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3434                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3435                     .toString())
3436             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3437             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3438             .build();
3439     mockDlpService.addResponse(expectedResponse);
3440 
3441     String parent = "parent-995424086";
3442     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3443 
3444     StoredInfoType actualResponse = client.createStoredInfoType(parent, config);
3445     Assert.assertEquals(expectedResponse, actualResponse);
3446 
3447     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3448     Assert.assertEquals(1, actualRequests.size());
3449     CreateStoredInfoTypeRequest actualRequest =
3450         ((CreateStoredInfoTypeRequest) actualRequests.get(0));
3451 
3452     Assert.assertEquals(parent, actualRequest.getParent());
3453     Assert.assertEquals(config, actualRequest.getConfig());
3454     Assert.assertTrue(
3455         channelProvider.isHeaderSent(
3456             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3457             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3458   }
3459 
3460   @Test
createStoredInfoTypeExceptionTest5()3461   public void createStoredInfoTypeExceptionTest5() throws Exception {
3462     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3463     mockDlpService.addException(exception);
3464 
3465     try {
3466       String parent = "parent-995424086";
3467       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3468       client.createStoredInfoType(parent, config);
3469       Assert.fail("No exception raised");
3470     } catch (InvalidArgumentException e) {
3471       // Expected exception.
3472     }
3473   }
3474 
3475   @Test
updateStoredInfoTypeTest()3476   public void updateStoredInfoTypeTest() throws Exception {
3477     StoredInfoType expectedResponse =
3478         StoredInfoType.newBuilder()
3479             .setName(
3480                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3481                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3482                     .toString())
3483             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3484             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3485             .build();
3486     mockDlpService.addResponse(expectedResponse);
3487 
3488     StoredInfoTypeName name =
3489         StoredInfoTypeName.ofOrganizationStoredInfoTypeName("[ORGANIZATION]", "[STORED_INFO_TYPE]");
3490     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3491     FieldMask updateMask = FieldMask.newBuilder().build();
3492 
3493     StoredInfoType actualResponse = client.updateStoredInfoType(name, config, updateMask);
3494     Assert.assertEquals(expectedResponse, actualResponse);
3495 
3496     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3497     Assert.assertEquals(1, actualRequests.size());
3498     UpdateStoredInfoTypeRequest actualRequest =
3499         ((UpdateStoredInfoTypeRequest) actualRequests.get(0));
3500 
3501     Assert.assertEquals(name.toString(), actualRequest.getName());
3502     Assert.assertEquals(config, actualRequest.getConfig());
3503     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
3504     Assert.assertTrue(
3505         channelProvider.isHeaderSent(
3506             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3507             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3508   }
3509 
3510   @Test
updateStoredInfoTypeExceptionTest()3511   public void updateStoredInfoTypeExceptionTest() throws Exception {
3512     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3513     mockDlpService.addException(exception);
3514 
3515     try {
3516       StoredInfoTypeName name =
3517           StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3518               "[ORGANIZATION]", "[STORED_INFO_TYPE]");
3519       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3520       FieldMask updateMask = FieldMask.newBuilder().build();
3521       client.updateStoredInfoType(name, config, updateMask);
3522       Assert.fail("No exception raised");
3523     } catch (InvalidArgumentException e) {
3524       // Expected exception.
3525     }
3526   }
3527 
3528   @Test
updateStoredInfoTypeTest2()3529   public void updateStoredInfoTypeTest2() throws Exception {
3530     StoredInfoType expectedResponse =
3531         StoredInfoType.newBuilder()
3532             .setName(
3533                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3534                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3535                     .toString())
3536             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3537             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3538             .build();
3539     mockDlpService.addResponse(expectedResponse);
3540 
3541     String name = "name3373707";
3542     StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3543     FieldMask updateMask = FieldMask.newBuilder().build();
3544 
3545     StoredInfoType actualResponse = client.updateStoredInfoType(name, config, updateMask);
3546     Assert.assertEquals(expectedResponse, actualResponse);
3547 
3548     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3549     Assert.assertEquals(1, actualRequests.size());
3550     UpdateStoredInfoTypeRequest actualRequest =
3551         ((UpdateStoredInfoTypeRequest) actualRequests.get(0));
3552 
3553     Assert.assertEquals(name, actualRequest.getName());
3554     Assert.assertEquals(config, actualRequest.getConfig());
3555     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
3556     Assert.assertTrue(
3557         channelProvider.isHeaderSent(
3558             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3559             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3560   }
3561 
3562   @Test
updateStoredInfoTypeExceptionTest2()3563   public void updateStoredInfoTypeExceptionTest2() throws Exception {
3564     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3565     mockDlpService.addException(exception);
3566 
3567     try {
3568       String name = "name3373707";
3569       StoredInfoTypeConfig config = StoredInfoTypeConfig.newBuilder().build();
3570       FieldMask updateMask = FieldMask.newBuilder().build();
3571       client.updateStoredInfoType(name, config, updateMask);
3572       Assert.fail("No exception raised");
3573     } catch (InvalidArgumentException e) {
3574       // Expected exception.
3575     }
3576   }
3577 
3578   @Test
getStoredInfoTypeTest()3579   public void getStoredInfoTypeTest() throws Exception {
3580     StoredInfoType expectedResponse =
3581         StoredInfoType.newBuilder()
3582             .setName(
3583                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3584                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3585                     .toString())
3586             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3587             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3588             .build();
3589     mockDlpService.addResponse(expectedResponse);
3590 
3591     StoredInfoTypeName name =
3592         StoredInfoTypeName.ofOrganizationStoredInfoTypeName("[ORGANIZATION]", "[STORED_INFO_TYPE]");
3593 
3594     StoredInfoType actualResponse = client.getStoredInfoType(name);
3595     Assert.assertEquals(expectedResponse, actualResponse);
3596 
3597     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3598     Assert.assertEquals(1, actualRequests.size());
3599     GetStoredInfoTypeRequest actualRequest = ((GetStoredInfoTypeRequest) actualRequests.get(0));
3600 
3601     Assert.assertEquals(name.toString(), actualRequest.getName());
3602     Assert.assertTrue(
3603         channelProvider.isHeaderSent(
3604             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3605             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3606   }
3607 
3608   @Test
getStoredInfoTypeExceptionTest()3609   public void getStoredInfoTypeExceptionTest() throws Exception {
3610     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3611     mockDlpService.addException(exception);
3612 
3613     try {
3614       StoredInfoTypeName name =
3615           StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3616               "[ORGANIZATION]", "[STORED_INFO_TYPE]");
3617       client.getStoredInfoType(name);
3618       Assert.fail("No exception raised");
3619     } catch (InvalidArgumentException e) {
3620       // Expected exception.
3621     }
3622   }
3623 
3624   @Test
getStoredInfoTypeTest2()3625   public void getStoredInfoTypeTest2() throws Exception {
3626     StoredInfoType expectedResponse =
3627         StoredInfoType.newBuilder()
3628             .setName(
3629                 StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3630                         "[ORGANIZATION]", "[STORED_INFO_TYPE]")
3631                     .toString())
3632             .setCurrentVersion(StoredInfoTypeVersion.newBuilder().build())
3633             .addAllPendingVersions(new ArrayList<StoredInfoTypeVersion>())
3634             .build();
3635     mockDlpService.addResponse(expectedResponse);
3636 
3637     String name = "name3373707";
3638 
3639     StoredInfoType actualResponse = client.getStoredInfoType(name);
3640     Assert.assertEquals(expectedResponse, actualResponse);
3641 
3642     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3643     Assert.assertEquals(1, actualRequests.size());
3644     GetStoredInfoTypeRequest actualRequest = ((GetStoredInfoTypeRequest) actualRequests.get(0));
3645 
3646     Assert.assertEquals(name, actualRequest.getName());
3647     Assert.assertTrue(
3648         channelProvider.isHeaderSent(
3649             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3650             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3651   }
3652 
3653   @Test
getStoredInfoTypeExceptionTest2()3654   public void getStoredInfoTypeExceptionTest2() throws Exception {
3655     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3656     mockDlpService.addException(exception);
3657 
3658     try {
3659       String name = "name3373707";
3660       client.getStoredInfoType(name);
3661       Assert.fail("No exception raised");
3662     } catch (InvalidArgumentException e) {
3663       // Expected exception.
3664     }
3665   }
3666 
3667   @Test
listStoredInfoTypesTest()3668   public void listStoredInfoTypesTest() throws Exception {
3669     StoredInfoType responsesElement = StoredInfoType.newBuilder().build();
3670     ListStoredInfoTypesResponse expectedResponse =
3671         ListStoredInfoTypesResponse.newBuilder()
3672             .setNextPageToken("")
3673             .addAllStoredInfoTypes(Arrays.asList(responsesElement))
3674             .build();
3675     mockDlpService.addResponse(expectedResponse);
3676 
3677     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3678 
3679     ListStoredInfoTypesPagedResponse pagedListResponse = client.listStoredInfoTypes(parent);
3680 
3681     List<StoredInfoType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3682 
3683     Assert.assertEquals(1, resources.size());
3684     Assert.assertEquals(expectedResponse.getStoredInfoTypesList().get(0), resources.get(0));
3685 
3686     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3687     Assert.assertEquals(1, actualRequests.size());
3688     ListStoredInfoTypesRequest actualRequest = ((ListStoredInfoTypesRequest) actualRequests.get(0));
3689 
3690     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3691     Assert.assertTrue(
3692         channelProvider.isHeaderSent(
3693             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3694             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3695   }
3696 
3697   @Test
listStoredInfoTypesExceptionTest()3698   public void listStoredInfoTypesExceptionTest() throws Exception {
3699     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3700     mockDlpService.addException(exception);
3701 
3702     try {
3703       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3704       client.listStoredInfoTypes(parent);
3705       Assert.fail("No exception raised");
3706     } catch (InvalidArgumentException e) {
3707       // Expected exception.
3708     }
3709   }
3710 
3711   @Test
listStoredInfoTypesTest2()3712   public void listStoredInfoTypesTest2() throws Exception {
3713     StoredInfoType responsesElement = StoredInfoType.newBuilder().build();
3714     ListStoredInfoTypesResponse expectedResponse =
3715         ListStoredInfoTypesResponse.newBuilder()
3716             .setNextPageToken("")
3717             .addAllStoredInfoTypes(Arrays.asList(responsesElement))
3718             .build();
3719     mockDlpService.addResponse(expectedResponse);
3720 
3721     OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
3722 
3723     ListStoredInfoTypesPagedResponse pagedListResponse = client.listStoredInfoTypes(parent);
3724 
3725     List<StoredInfoType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3726 
3727     Assert.assertEquals(1, resources.size());
3728     Assert.assertEquals(expectedResponse.getStoredInfoTypesList().get(0), resources.get(0));
3729 
3730     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3731     Assert.assertEquals(1, actualRequests.size());
3732     ListStoredInfoTypesRequest actualRequest = ((ListStoredInfoTypesRequest) actualRequests.get(0));
3733 
3734     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3735     Assert.assertTrue(
3736         channelProvider.isHeaderSent(
3737             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3738             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3739   }
3740 
3741   @Test
listStoredInfoTypesExceptionTest2()3742   public void listStoredInfoTypesExceptionTest2() throws Exception {
3743     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3744     mockDlpService.addException(exception);
3745 
3746     try {
3747       OrganizationLocationName parent = OrganizationLocationName.of("[ORGANIZATION]", "[LOCATION]");
3748       client.listStoredInfoTypes(parent);
3749       Assert.fail("No exception raised");
3750     } catch (InvalidArgumentException e) {
3751       // Expected exception.
3752     }
3753   }
3754 
3755   @Test
listStoredInfoTypesTest3()3756   public void listStoredInfoTypesTest3() throws Exception {
3757     StoredInfoType responsesElement = StoredInfoType.newBuilder().build();
3758     ListStoredInfoTypesResponse expectedResponse =
3759         ListStoredInfoTypesResponse.newBuilder()
3760             .setNextPageToken("")
3761             .addAllStoredInfoTypes(Arrays.asList(responsesElement))
3762             .build();
3763     mockDlpService.addResponse(expectedResponse);
3764 
3765     OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
3766 
3767     ListStoredInfoTypesPagedResponse pagedListResponse = client.listStoredInfoTypes(parent);
3768 
3769     List<StoredInfoType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3770 
3771     Assert.assertEquals(1, resources.size());
3772     Assert.assertEquals(expectedResponse.getStoredInfoTypesList().get(0), resources.get(0));
3773 
3774     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3775     Assert.assertEquals(1, actualRequests.size());
3776     ListStoredInfoTypesRequest actualRequest = ((ListStoredInfoTypesRequest) actualRequests.get(0));
3777 
3778     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3779     Assert.assertTrue(
3780         channelProvider.isHeaderSent(
3781             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3782             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3783   }
3784 
3785   @Test
listStoredInfoTypesExceptionTest3()3786   public void listStoredInfoTypesExceptionTest3() throws Exception {
3787     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3788     mockDlpService.addException(exception);
3789 
3790     try {
3791       OrganizationName parent = OrganizationName.of("[ORGANIZATION]");
3792       client.listStoredInfoTypes(parent);
3793       Assert.fail("No exception raised");
3794     } catch (InvalidArgumentException e) {
3795       // Expected exception.
3796     }
3797   }
3798 
3799   @Test
listStoredInfoTypesTest4()3800   public void listStoredInfoTypesTest4() throws Exception {
3801     StoredInfoType responsesElement = StoredInfoType.newBuilder().build();
3802     ListStoredInfoTypesResponse expectedResponse =
3803         ListStoredInfoTypesResponse.newBuilder()
3804             .setNextPageToken("")
3805             .addAllStoredInfoTypes(Arrays.asList(responsesElement))
3806             .build();
3807     mockDlpService.addResponse(expectedResponse);
3808 
3809     ProjectName parent = ProjectName.of("[PROJECT]");
3810 
3811     ListStoredInfoTypesPagedResponse pagedListResponse = client.listStoredInfoTypes(parent);
3812 
3813     List<StoredInfoType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3814 
3815     Assert.assertEquals(1, resources.size());
3816     Assert.assertEquals(expectedResponse.getStoredInfoTypesList().get(0), resources.get(0));
3817 
3818     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3819     Assert.assertEquals(1, actualRequests.size());
3820     ListStoredInfoTypesRequest actualRequest = ((ListStoredInfoTypesRequest) actualRequests.get(0));
3821 
3822     Assert.assertEquals(parent.toString(), actualRequest.getParent());
3823     Assert.assertTrue(
3824         channelProvider.isHeaderSent(
3825             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3826             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3827   }
3828 
3829   @Test
listStoredInfoTypesExceptionTest4()3830   public void listStoredInfoTypesExceptionTest4() throws Exception {
3831     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3832     mockDlpService.addException(exception);
3833 
3834     try {
3835       ProjectName parent = ProjectName.of("[PROJECT]");
3836       client.listStoredInfoTypes(parent);
3837       Assert.fail("No exception raised");
3838     } catch (InvalidArgumentException e) {
3839       // Expected exception.
3840     }
3841   }
3842 
3843   @Test
listStoredInfoTypesTest5()3844   public void listStoredInfoTypesTest5() throws Exception {
3845     StoredInfoType responsesElement = StoredInfoType.newBuilder().build();
3846     ListStoredInfoTypesResponse expectedResponse =
3847         ListStoredInfoTypesResponse.newBuilder()
3848             .setNextPageToken("")
3849             .addAllStoredInfoTypes(Arrays.asList(responsesElement))
3850             .build();
3851     mockDlpService.addResponse(expectedResponse);
3852 
3853     String parent = "parent-995424086";
3854 
3855     ListStoredInfoTypesPagedResponse pagedListResponse = client.listStoredInfoTypes(parent);
3856 
3857     List<StoredInfoType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3858 
3859     Assert.assertEquals(1, resources.size());
3860     Assert.assertEquals(expectedResponse.getStoredInfoTypesList().get(0), resources.get(0));
3861 
3862     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3863     Assert.assertEquals(1, actualRequests.size());
3864     ListStoredInfoTypesRequest actualRequest = ((ListStoredInfoTypesRequest) actualRequests.get(0));
3865 
3866     Assert.assertEquals(parent, actualRequest.getParent());
3867     Assert.assertTrue(
3868         channelProvider.isHeaderSent(
3869             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3870             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3871   }
3872 
3873   @Test
listStoredInfoTypesExceptionTest5()3874   public void listStoredInfoTypesExceptionTest5() throws Exception {
3875     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3876     mockDlpService.addException(exception);
3877 
3878     try {
3879       String parent = "parent-995424086";
3880       client.listStoredInfoTypes(parent);
3881       Assert.fail("No exception raised");
3882     } catch (InvalidArgumentException e) {
3883       // Expected exception.
3884     }
3885   }
3886 
3887   @Test
deleteStoredInfoTypeTest()3888   public void deleteStoredInfoTypeTest() throws Exception {
3889     Empty expectedResponse = Empty.newBuilder().build();
3890     mockDlpService.addResponse(expectedResponse);
3891 
3892     StoredInfoTypeName name =
3893         StoredInfoTypeName.ofOrganizationStoredInfoTypeName("[ORGANIZATION]", "[STORED_INFO_TYPE]");
3894 
3895     client.deleteStoredInfoType(name);
3896 
3897     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3898     Assert.assertEquals(1, actualRequests.size());
3899     DeleteStoredInfoTypeRequest actualRequest =
3900         ((DeleteStoredInfoTypeRequest) actualRequests.get(0));
3901 
3902     Assert.assertEquals(name.toString(), actualRequest.getName());
3903     Assert.assertTrue(
3904         channelProvider.isHeaderSent(
3905             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3906             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3907   }
3908 
3909   @Test
deleteStoredInfoTypeExceptionTest()3910   public void deleteStoredInfoTypeExceptionTest() throws Exception {
3911     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3912     mockDlpService.addException(exception);
3913 
3914     try {
3915       StoredInfoTypeName name =
3916           StoredInfoTypeName.ofOrganizationStoredInfoTypeName(
3917               "[ORGANIZATION]", "[STORED_INFO_TYPE]");
3918       client.deleteStoredInfoType(name);
3919       Assert.fail("No exception raised");
3920     } catch (InvalidArgumentException e) {
3921       // Expected exception.
3922     }
3923   }
3924 
3925   @Test
deleteStoredInfoTypeTest2()3926   public void deleteStoredInfoTypeTest2() throws Exception {
3927     Empty expectedResponse = Empty.newBuilder().build();
3928     mockDlpService.addResponse(expectedResponse);
3929 
3930     String name = "name3373707";
3931 
3932     client.deleteStoredInfoType(name);
3933 
3934     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3935     Assert.assertEquals(1, actualRequests.size());
3936     DeleteStoredInfoTypeRequest actualRequest =
3937         ((DeleteStoredInfoTypeRequest) actualRequests.get(0));
3938 
3939     Assert.assertEquals(name, actualRequest.getName());
3940     Assert.assertTrue(
3941         channelProvider.isHeaderSent(
3942             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3943             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3944   }
3945 
3946   @Test
deleteStoredInfoTypeExceptionTest2()3947   public void deleteStoredInfoTypeExceptionTest2() throws Exception {
3948     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3949     mockDlpService.addException(exception);
3950 
3951     try {
3952       String name = "name3373707";
3953       client.deleteStoredInfoType(name);
3954       Assert.fail("No exception raised");
3955     } catch (InvalidArgumentException e) {
3956       // Expected exception.
3957     }
3958   }
3959 
3960   @Test
hybridInspectDlpJobTest()3961   public void hybridInspectDlpJobTest() throws Exception {
3962     HybridInspectResponse expectedResponse = HybridInspectResponse.newBuilder().build();
3963     mockDlpService.addResponse(expectedResponse);
3964 
3965     DlpJobName name =
3966         DlpJobName.ofProjectLocationDlpJobName("[PROJECT]", "[LOCATION]", "[DLP_JOB]");
3967 
3968     HybridInspectResponse actualResponse = client.hybridInspectDlpJob(name);
3969     Assert.assertEquals(expectedResponse, actualResponse);
3970 
3971     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
3972     Assert.assertEquals(1, actualRequests.size());
3973     HybridInspectDlpJobRequest actualRequest = ((HybridInspectDlpJobRequest) actualRequests.get(0));
3974 
3975     Assert.assertEquals(name.toString(), actualRequest.getName());
3976     Assert.assertTrue(
3977         channelProvider.isHeaderSent(
3978             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3979             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3980   }
3981 
3982   @Test
hybridInspectDlpJobExceptionTest()3983   public void hybridInspectDlpJobExceptionTest() throws Exception {
3984     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3985     mockDlpService.addException(exception);
3986 
3987     try {
3988       DlpJobName name =
3989           DlpJobName.ofProjectLocationDlpJobName("[PROJECT]", "[LOCATION]", "[DLP_JOB]");
3990       client.hybridInspectDlpJob(name);
3991       Assert.fail("No exception raised");
3992     } catch (InvalidArgumentException e) {
3993       // Expected exception.
3994     }
3995   }
3996 
3997   @Test
hybridInspectDlpJobTest2()3998   public void hybridInspectDlpJobTest2() throws Exception {
3999     HybridInspectResponse expectedResponse = HybridInspectResponse.newBuilder().build();
4000     mockDlpService.addResponse(expectedResponse);
4001 
4002     String name = "name3373707";
4003 
4004     HybridInspectResponse actualResponse = client.hybridInspectDlpJob(name);
4005     Assert.assertEquals(expectedResponse, actualResponse);
4006 
4007     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
4008     Assert.assertEquals(1, actualRequests.size());
4009     HybridInspectDlpJobRequest actualRequest = ((HybridInspectDlpJobRequest) actualRequests.get(0));
4010 
4011     Assert.assertEquals(name, actualRequest.getName());
4012     Assert.assertTrue(
4013         channelProvider.isHeaderSent(
4014             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4015             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4016   }
4017 
4018   @Test
hybridInspectDlpJobExceptionTest2()4019   public void hybridInspectDlpJobExceptionTest2() throws Exception {
4020     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4021     mockDlpService.addException(exception);
4022 
4023     try {
4024       String name = "name3373707";
4025       client.hybridInspectDlpJob(name);
4026       Assert.fail("No exception raised");
4027     } catch (InvalidArgumentException e) {
4028       // Expected exception.
4029     }
4030   }
4031 
4032   @Test
finishDlpJobTest()4033   public void finishDlpJobTest() throws Exception {
4034     Empty expectedResponse = Empty.newBuilder().build();
4035     mockDlpService.addResponse(expectedResponse);
4036 
4037     FinishDlpJobRequest request =
4038         FinishDlpJobRequest.newBuilder()
4039             .setName(
4040                 DlpJobName.ofProjectLocationDlpJobName("[PROJECT]", "[LOCATION]", "[DLP_JOB]")
4041                     .toString())
4042             .build();
4043 
4044     client.finishDlpJob(request);
4045 
4046     List<AbstractMessage> actualRequests = mockDlpService.getRequests();
4047     Assert.assertEquals(1, actualRequests.size());
4048     FinishDlpJobRequest actualRequest = ((FinishDlpJobRequest) actualRequests.get(0));
4049 
4050     Assert.assertEquals(request.getName(), actualRequest.getName());
4051     Assert.assertTrue(
4052         channelProvider.isHeaderSent(
4053             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
4054             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
4055   }
4056 
4057   @Test
finishDlpJobExceptionTest()4058   public void finishDlpJobExceptionTest() throws Exception {
4059     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
4060     mockDlpService.addException(exception);
4061 
4062     try {
4063       FinishDlpJobRequest request =
4064           FinishDlpJobRequest.newBuilder()
4065               .setName(
4066                   DlpJobName.ofProjectLocationDlpJobName("[PROJECT]", "[LOCATION]", "[DLP_JOB]")
4067                       .toString())
4068               .build();
4069       client.finishDlpJob(request);
4070       Assert.fail("No exception raised");
4071     } catch (InvalidArgumentException e) {
4072       // Expected exception.
4073     }
4074   }
4075 }
4076