• 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.documentai.v1beta3;
18 
19 import static com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient.ListEvaluationsPagedResponse;
20 import static com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient.ListLocationsPagedResponse;
21 import static com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient.ListProcessorTypesPagedResponse;
22 import static com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient.ListProcessorVersionsPagedResponse;
23 import static com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient.ListProcessorsPagedResponse;
24 
25 import com.google.api.LaunchStage;
26 import com.google.api.gax.core.NoCredentialsProvider;
27 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
28 import com.google.api.gax.httpjson.testing.MockHttpService;
29 import com.google.api.gax.rpc.ApiClientHeaderProvider;
30 import com.google.api.gax.rpc.ApiException;
31 import com.google.api.gax.rpc.ApiExceptionFactory;
32 import com.google.api.gax.rpc.InvalidArgumentException;
33 import com.google.api.gax.rpc.StatusCode;
34 import com.google.api.gax.rpc.testing.FakeStatusCode;
35 import com.google.api.resourcenames.ResourceName;
36 import com.google.cloud.documentai.v1beta3.stub.HttpJsonDocumentProcessorServiceStub;
37 import com.google.cloud.location.GetLocationRequest;
38 import com.google.cloud.location.ListLocationsRequest;
39 import com.google.cloud.location.ListLocationsResponse;
40 import com.google.cloud.location.Location;
41 import com.google.common.collect.Lists;
42 import com.google.longrunning.Operation;
43 import com.google.protobuf.Any;
44 import com.google.protobuf.Empty;
45 import com.google.protobuf.Timestamp;
46 import java.io.IOException;
47 import java.util.ArrayList;
48 import java.util.Arrays;
49 import java.util.HashMap;
50 import java.util.List;
51 import java.util.concurrent.ExecutionException;
52 import javax.annotation.Generated;
53 import org.junit.After;
54 import org.junit.AfterClass;
55 import org.junit.Assert;
56 import org.junit.Before;
57 import org.junit.BeforeClass;
58 import org.junit.Test;
59 
60 @Generated("by gapic-generator-java")
61 public class DocumentProcessorServiceClientHttpJsonTest {
62   private static MockHttpService mockService;
63   private static DocumentProcessorServiceClient client;
64 
65   @BeforeClass
startStaticServer()66   public static void startStaticServer() throws IOException {
67     mockService =
68         new MockHttpService(
69             HttpJsonDocumentProcessorServiceStub.getMethodDescriptors(),
70             DocumentProcessorServiceSettings.getDefaultEndpoint());
71     DocumentProcessorServiceSettings settings =
72         DocumentProcessorServiceSettings.newHttpJsonBuilder()
73             .setTransportChannelProvider(
74                 DocumentProcessorServiceSettings.defaultHttpJsonTransportProviderBuilder()
75                     .setHttpTransport(mockService)
76                     .build())
77             .setCredentialsProvider(NoCredentialsProvider.create())
78             .build();
79     client = DocumentProcessorServiceClient.create(settings);
80   }
81 
82   @AfterClass
stopServer()83   public static void stopServer() {
84     client.close();
85   }
86 
87   @Before
setUp()88   public void setUp() {}
89 
90   @After
tearDown()91   public void tearDown() throws Exception {
92     mockService.reset();
93   }
94 
95   @Test
processDocumentTest()96   public void processDocumentTest() throws Exception {
97     ProcessResponse expectedResponse =
98         ProcessResponse.newBuilder()
99             .setDocument(Document.newBuilder().build())
100             .setHumanReviewOperation("humanReviewOperation1807415298")
101             .setHumanReviewStatus(HumanReviewStatus.newBuilder().build())
102             .build();
103     mockService.addResponse(expectedResponse);
104 
105     ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
106 
107     ProcessResponse actualResponse = client.processDocument(name);
108     Assert.assertEquals(expectedResponse, actualResponse);
109 
110     List<String> actualRequests = mockService.getRequestPaths();
111     Assert.assertEquals(1, actualRequests.size());
112 
113     String apiClientHeaderKey =
114         mockService
115             .getRequestHeaders()
116             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
117             .iterator()
118             .next();
119     Assert.assertTrue(
120         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
121             .matcher(apiClientHeaderKey)
122             .matches());
123   }
124 
125   @Test
processDocumentExceptionTest()126   public void processDocumentExceptionTest() throws Exception {
127     ApiException exception =
128         ApiExceptionFactory.createException(
129             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
130     mockService.addException(exception);
131 
132     try {
133       ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
134       client.processDocument(name);
135       Assert.fail("No exception raised");
136     } catch (InvalidArgumentException e) {
137       // Expected exception.
138     }
139   }
140 
141   @Test
processDocumentTest2()142   public void processDocumentTest2() throws Exception {
143     ProcessResponse expectedResponse =
144         ProcessResponse.newBuilder()
145             .setDocument(Document.newBuilder().build())
146             .setHumanReviewOperation("humanReviewOperation1807415298")
147             .setHumanReviewStatus(HumanReviewStatus.newBuilder().build())
148             .build();
149     mockService.addResponse(expectedResponse);
150 
151     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
152 
153     ProcessResponse actualResponse = client.processDocument(name);
154     Assert.assertEquals(expectedResponse, actualResponse);
155 
156     List<String> actualRequests = mockService.getRequestPaths();
157     Assert.assertEquals(1, actualRequests.size());
158 
159     String apiClientHeaderKey =
160         mockService
161             .getRequestHeaders()
162             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
163             .iterator()
164             .next();
165     Assert.assertTrue(
166         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
167             .matcher(apiClientHeaderKey)
168             .matches());
169   }
170 
171   @Test
processDocumentExceptionTest2()172   public void processDocumentExceptionTest2() throws Exception {
173     ApiException exception =
174         ApiExceptionFactory.createException(
175             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
176     mockService.addException(exception);
177 
178     try {
179       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
180       client.processDocument(name);
181       Assert.fail("No exception raised");
182     } catch (InvalidArgumentException e) {
183       // Expected exception.
184     }
185   }
186 
187   @Test
batchProcessDocumentsTest()188   public void batchProcessDocumentsTest() throws Exception {
189     BatchProcessResponse expectedResponse = BatchProcessResponse.newBuilder().build();
190     Operation resultOperation =
191         Operation.newBuilder()
192             .setName("batchProcessDocumentsTest")
193             .setDone(true)
194             .setResponse(Any.pack(expectedResponse))
195             .build();
196     mockService.addResponse(resultOperation);
197 
198     ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
199 
200     BatchProcessResponse actualResponse = client.batchProcessDocumentsAsync(name).get();
201     Assert.assertEquals(expectedResponse, actualResponse);
202 
203     List<String> actualRequests = mockService.getRequestPaths();
204     Assert.assertEquals(1, actualRequests.size());
205 
206     String apiClientHeaderKey =
207         mockService
208             .getRequestHeaders()
209             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
210             .iterator()
211             .next();
212     Assert.assertTrue(
213         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
214             .matcher(apiClientHeaderKey)
215             .matches());
216   }
217 
218   @Test
batchProcessDocumentsExceptionTest()219   public void batchProcessDocumentsExceptionTest() throws Exception {
220     ApiException exception =
221         ApiExceptionFactory.createException(
222             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
223     mockService.addException(exception);
224 
225     try {
226       ResourceName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
227       client.batchProcessDocumentsAsync(name).get();
228       Assert.fail("No exception raised");
229     } catch (ExecutionException e) {
230     }
231   }
232 
233   @Test
batchProcessDocumentsTest2()234   public void batchProcessDocumentsTest2() throws Exception {
235     BatchProcessResponse expectedResponse = BatchProcessResponse.newBuilder().build();
236     Operation resultOperation =
237         Operation.newBuilder()
238             .setName("batchProcessDocumentsTest")
239             .setDone(true)
240             .setResponse(Any.pack(expectedResponse))
241             .build();
242     mockService.addResponse(resultOperation);
243 
244     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
245 
246     BatchProcessResponse actualResponse = client.batchProcessDocumentsAsync(name).get();
247     Assert.assertEquals(expectedResponse, actualResponse);
248 
249     List<String> actualRequests = mockService.getRequestPaths();
250     Assert.assertEquals(1, actualRequests.size());
251 
252     String apiClientHeaderKey =
253         mockService
254             .getRequestHeaders()
255             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
256             .iterator()
257             .next();
258     Assert.assertTrue(
259         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
260             .matcher(apiClientHeaderKey)
261             .matches());
262   }
263 
264   @Test
batchProcessDocumentsExceptionTest2()265   public void batchProcessDocumentsExceptionTest2() throws Exception {
266     ApiException exception =
267         ApiExceptionFactory.createException(
268             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
269     mockService.addException(exception);
270 
271     try {
272       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
273       client.batchProcessDocumentsAsync(name).get();
274       Assert.fail("No exception raised");
275     } catch (ExecutionException e) {
276     }
277   }
278 
279   @Test
fetchProcessorTypesTest()280   public void fetchProcessorTypesTest() throws Exception {
281     FetchProcessorTypesResponse expectedResponse =
282         FetchProcessorTypesResponse.newBuilder()
283             .addAllProcessorTypes(new ArrayList<ProcessorType>())
284             .build();
285     mockService.addResponse(expectedResponse);
286 
287     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
288 
289     FetchProcessorTypesResponse actualResponse = client.fetchProcessorTypes(parent);
290     Assert.assertEquals(expectedResponse, actualResponse);
291 
292     List<String> actualRequests = mockService.getRequestPaths();
293     Assert.assertEquals(1, actualRequests.size());
294 
295     String apiClientHeaderKey =
296         mockService
297             .getRequestHeaders()
298             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
299             .iterator()
300             .next();
301     Assert.assertTrue(
302         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
303             .matcher(apiClientHeaderKey)
304             .matches());
305   }
306 
307   @Test
fetchProcessorTypesExceptionTest()308   public void fetchProcessorTypesExceptionTest() throws Exception {
309     ApiException exception =
310         ApiExceptionFactory.createException(
311             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
312     mockService.addException(exception);
313 
314     try {
315       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
316       client.fetchProcessorTypes(parent);
317       Assert.fail("No exception raised");
318     } catch (InvalidArgumentException e) {
319       // Expected exception.
320     }
321   }
322 
323   @Test
fetchProcessorTypesTest2()324   public void fetchProcessorTypesTest2() throws Exception {
325     FetchProcessorTypesResponse expectedResponse =
326         FetchProcessorTypesResponse.newBuilder()
327             .addAllProcessorTypes(new ArrayList<ProcessorType>())
328             .build();
329     mockService.addResponse(expectedResponse);
330 
331     String parent = "projects/project-5833/locations/location-5833";
332 
333     FetchProcessorTypesResponse actualResponse = client.fetchProcessorTypes(parent);
334     Assert.assertEquals(expectedResponse, actualResponse);
335 
336     List<String> actualRequests = mockService.getRequestPaths();
337     Assert.assertEquals(1, actualRequests.size());
338 
339     String apiClientHeaderKey =
340         mockService
341             .getRequestHeaders()
342             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
343             .iterator()
344             .next();
345     Assert.assertTrue(
346         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
347             .matcher(apiClientHeaderKey)
348             .matches());
349   }
350 
351   @Test
fetchProcessorTypesExceptionTest2()352   public void fetchProcessorTypesExceptionTest2() throws Exception {
353     ApiException exception =
354         ApiExceptionFactory.createException(
355             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
356     mockService.addException(exception);
357 
358     try {
359       String parent = "projects/project-5833/locations/location-5833";
360       client.fetchProcessorTypes(parent);
361       Assert.fail("No exception raised");
362     } catch (InvalidArgumentException e) {
363       // Expected exception.
364     }
365   }
366 
367   @Test
listProcessorTypesTest()368   public void listProcessorTypesTest() throws Exception {
369     ProcessorType responsesElement = ProcessorType.newBuilder().build();
370     ListProcessorTypesResponse expectedResponse =
371         ListProcessorTypesResponse.newBuilder()
372             .setNextPageToken("")
373             .addAllProcessorTypes(Arrays.asList(responsesElement))
374             .build();
375     mockService.addResponse(expectedResponse);
376 
377     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
378 
379     ListProcessorTypesPagedResponse pagedListResponse = client.listProcessorTypes(parent);
380 
381     List<ProcessorType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
382 
383     Assert.assertEquals(1, resources.size());
384     Assert.assertEquals(expectedResponse.getProcessorTypesList().get(0), resources.get(0));
385 
386     List<String> actualRequests = mockService.getRequestPaths();
387     Assert.assertEquals(1, actualRequests.size());
388 
389     String apiClientHeaderKey =
390         mockService
391             .getRequestHeaders()
392             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
393             .iterator()
394             .next();
395     Assert.assertTrue(
396         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
397             .matcher(apiClientHeaderKey)
398             .matches());
399   }
400 
401   @Test
listProcessorTypesExceptionTest()402   public void listProcessorTypesExceptionTest() throws Exception {
403     ApiException exception =
404         ApiExceptionFactory.createException(
405             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
406     mockService.addException(exception);
407 
408     try {
409       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
410       client.listProcessorTypes(parent);
411       Assert.fail("No exception raised");
412     } catch (InvalidArgumentException e) {
413       // Expected exception.
414     }
415   }
416 
417   @Test
listProcessorTypesTest2()418   public void listProcessorTypesTest2() throws Exception {
419     ProcessorType responsesElement = ProcessorType.newBuilder().build();
420     ListProcessorTypesResponse expectedResponse =
421         ListProcessorTypesResponse.newBuilder()
422             .setNextPageToken("")
423             .addAllProcessorTypes(Arrays.asList(responsesElement))
424             .build();
425     mockService.addResponse(expectedResponse);
426 
427     String parent = "projects/project-5833/locations/location-5833";
428 
429     ListProcessorTypesPagedResponse pagedListResponse = client.listProcessorTypes(parent);
430 
431     List<ProcessorType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
432 
433     Assert.assertEquals(1, resources.size());
434     Assert.assertEquals(expectedResponse.getProcessorTypesList().get(0), resources.get(0));
435 
436     List<String> actualRequests = mockService.getRequestPaths();
437     Assert.assertEquals(1, actualRequests.size());
438 
439     String apiClientHeaderKey =
440         mockService
441             .getRequestHeaders()
442             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
443             .iterator()
444             .next();
445     Assert.assertTrue(
446         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
447             .matcher(apiClientHeaderKey)
448             .matches());
449   }
450 
451   @Test
listProcessorTypesExceptionTest2()452   public void listProcessorTypesExceptionTest2() throws Exception {
453     ApiException exception =
454         ApiExceptionFactory.createException(
455             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
456     mockService.addException(exception);
457 
458     try {
459       String parent = "projects/project-5833/locations/location-5833";
460       client.listProcessorTypes(parent);
461       Assert.fail("No exception raised");
462     } catch (InvalidArgumentException e) {
463       // Expected exception.
464     }
465   }
466 
467   @Test
getProcessorTypeTest()468   public void getProcessorTypeTest() throws Exception {
469     ProcessorType expectedResponse =
470         ProcessorType.newBuilder()
471             .setName(ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]").toString())
472             .setType("type3575610")
473             .setCategory("category50511102")
474             .addAllAvailableLocations(new ArrayList<ProcessorType.LocationInfo>())
475             .setAllowCreation(true)
476             .setLaunchStage(LaunchStage.forNumber(0))
477             .addAllSampleDocumentUris(new ArrayList<String>())
478             .build();
479     mockService.addResponse(expectedResponse);
480 
481     ProcessorTypeName name = ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]");
482 
483     ProcessorType actualResponse = client.getProcessorType(name);
484     Assert.assertEquals(expectedResponse, actualResponse);
485 
486     List<String> actualRequests = mockService.getRequestPaths();
487     Assert.assertEquals(1, actualRequests.size());
488 
489     String apiClientHeaderKey =
490         mockService
491             .getRequestHeaders()
492             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
493             .iterator()
494             .next();
495     Assert.assertTrue(
496         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
497             .matcher(apiClientHeaderKey)
498             .matches());
499   }
500 
501   @Test
getProcessorTypeExceptionTest()502   public void getProcessorTypeExceptionTest() throws Exception {
503     ApiException exception =
504         ApiExceptionFactory.createException(
505             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
506     mockService.addException(exception);
507 
508     try {
509       ProcessorTypeName name = ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]");
510       client.getProcessorType(name);
511       Assert.fail("No exception raised");
512     } catch (InvalidArgumentException e) {
513       // Expected exception.
514     }
515   }
516 
517   @Test
getProcessorTypeTest2()518   public void getProcessorTypeTest2() throws Exception {
519     ProcessorType expectedResponse =
520         ProcessorType.newBuilder()
521             .setName(ProcessorTypeName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR_TYPE]").toString())
522             .setType("type3575610")
523             .setCategory("category50511102")
524             .addAllAvailableLocations(new ArrayList<ProcessorType.LocationInfo>())
525             .setAllowCreation(true)
526             .setLaunchStage(LaunchStage.forNumber(0))
527             .addAllSampleDocumentUris(new ArrayList<String>())
528             .build();
529     mockService.addResponse(expectedResponse);
530 
531     String name = "projects/project-6471/locations/location-6471/processorTypes/processorType-6471";
532 
533     ProcessorType actualResponse = client.getProcessorType(name);
534     Assert.assertEquals(expectedResponse, actualResponse);
535 
536     List<String> actualRequests = mockService.getRequestPaths();
537     Assert.assertEquals(1, actualRequests.size());
538 
539     String apiClientHeaderKey =
540         mockService
541             .getRequestHeaders()
542             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
543             .iterator()
544             .next();
545     Assert.assertTrue(
546         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
547             .matcher(apiClientHeaderKey)
548             .matches());
549   }
550 
551   @Test
getProcessorTypeExceptionTest2()552   public void getProcessorTypeExceptionTest2() throws Exception {
553     ApiException exception =
554         ApiExceptionFactory.createException(
555             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
556     mockService.addException(exception);
557 
558     try {
559       String name =
560           "projects/project-6471/locations/location-6471/processorTypes/processorType-6471";
561       client.getProcessorType(name);
562       Assert.fail("No exception raised");
563     } catch (InvalidArgumentException e) {
564       // Expected exception.
565     }
566   }
567 
568   @Test
listProcessorsTest()569   public void listProcessorsTest() throws Exception {
570     Processor responsesElement = Processor.newBuilder().build();
571     ListProcessorsResponse expectedResponse =
572         ListProcessorsResponse.newBuilder()
573             .setNextPageToken("")
574             .addAllProcessors(Arrays.asList(responsesElement))
575             .build();
576     mockService.addResponse(expectedResponse);
577 
578     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
579 
580     ListProcessorsPagedResponse pagedListResponse = client.listProcessors(parent);
581 
582     List<Processor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
583 
584     Assert.assertEquals(1, resources.size());
585     Assert.assertEquals(expectedResponse.getProcessorsList().get(0), resources.get(0));
586 
587     List<String> actualRequests = mockService.getRequestPaths();
588     Assert.assertEquals(1, actualRequests.size());
589 
590     String apiClientHeaderKey =
591         mockService
592             .getRequestHeaders()
593             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
594             .iterator()
595             .next();
596     Assert.assertTrue(
597         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
598             .matcher(apiClientHeaderKey)
599             .matches());
600   }
601 
602   @Test
listProcessorsExceptionTest()603   public void listProcessorsExceptionTest() throws Exception {
604     ApiException exception =
605         ApiExceptionFactory.createException(
606             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
607     mockService.addException(exception);
608 
609     try {
610       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
611       client.listProcessors(parent);
612       Assert.fail("No exception raised");
613     } catch (InvalidArgumentException e) {
614       // Expected exception.
615     }
616   }
617 
618   @Test
listProcessorsTest2()619   public void listProcessorsTest2() throws Exception {
620     Processor responsesElement = Processor.newBuilder().build();
621     ListProcessorsResponse expectedResponse =
622         ListProcessorsResponse.newBuilder()
623             .setNextPageToken("")
624             .addAllProcessors(Arrays.asList(responsesElement))
625             .build();
626     mockService.addResponse(expectedResponse);
627 
628     String parent = "projects/project-5833/locations/location-5833";
629 
630     ListProcessorsPagedResponse pagedListResponse = client.listProcessors(parent);
631 
632     List<Processor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
633 
634     Assert.assertEquals(1, resources.size());
635     Assert.assertEquals(expectedResponse.getProcessorsList().get(0), resources.get(0));
636 
637     List<String> actualRequests = mockService.getRequestPaths();
638     Assert.assertEquals(1, actualRequests.size());
639 
640     String apiClientHeaderKey =
641         mockService
642             .getRequestHeaders()
643             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
644             .iterator()
645             .next();
646     Assert.assertTrue(
647         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
648             .matcher(apiClientHeaderKey)
649             .matches());
650   }
651 
652   @Test
listProcessorsExceptionTest2()653   public void listProcessorsExceptionTest2() throws Exception {
654     ApiException exception =
655         ApiExceptionFactory.createException(
656             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
657     mockService.addException(exception);
658 
659     try {
660       String parent = "projects/project-5833/locations/location-5833";
661       client.listProcessors(parent);
662       Assert.fail("No exception raised");
663     } catch (InvalidArgumentException e) {
664       // Expected exception.
665     }
666   }
667 
668   @Test
getProcessorTest()669   public void getProcessorTest() throws Exception {
670     Processor expectedResponse =
671         Processor.newBuilder()
672             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
673             .setType("type3575610")
674             .setDisplayName("displayName1714148973")
675             .setDefaultProcessorVersion(
676                 ProcessorVersionName.of(
677                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
678                     .toString())
679             .setProcessEndpoint("processEndpoint-891502300")
680             .setCreateTime(Timestamp.newBuilder().build())
681             .setKmsKeyName("kmsKeyName412586233")
682             .build();
683     mockService.addResponse(expectedResponse);
684 
685     ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
686 
687     Processor actualResponse = client.getProcessor(name);
688     Assert.assertEquals(expectedResponse, actualResponse);
689 
690     List<String> actualRequests = mockService.getRequestPaths();
691     Assert.assertEquals(1, actualRequests.size());
692 
693     String apiClientHeaderKey =
694         mockService
695             .getRequestHeaders()
696             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
697             .iterator()
698             .next();
699     Assert.assertTrue(
700         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
701             .matcher(apiClientHeaderKey)
702             .matches());
703   }
704 
705   @Test
getProcessorExceptionTest()706   public void getProcessorExceptionTest() throws Exception {
707     ApiException exception =
708         ApiExceptionFactory.createException(
709             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
710     mockService.addException(exception);
711 
712     try {
713       ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
714       client.getProcessor(name);
715       Assert.fail("No exception raised");
716     } catch (InvalidArgumentException e) {
717       // Expected exception.
718     }
719   }
720 
721   @Test
getProcessorTest2()722   public void getProcessorTest2() throws Exception {
723     Processor expectedResponse =
724         Processor.newBuilder()
725             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
726             .setType("type3575610")
727             .setDisplayName("displayName1714148973")
728             .setDefaultProcessorVersion(
729                 ProcessorVersionName.of(
730                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
731                     .toString())
732             .setProcessEndpoint("processEndpoint-891502300")
733             .setCreateTime(Timestamp.newBuilder().build())
734             .setKmsKeyName("kmsKeyName412586233")
735             .build();
736     mockService.addResponse(expectedResponse);
737 
738     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
739 
740     Processor actualResponse = client.getProcessor(name);
741     Assert.assertEquals(expectedResponse, actualResponse);
742 
743     List<String> actualRequests = mockService.getRequestPaths();
744     Assert.assertEquals(1, actualRequests.size());
745 
746     String apiClientHeaderKey =
747         mockService
748             .getRequestHeaders()
749             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
750             .iterator()
751             .next();
752     Assert.assertTrue(
753         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
754             .matcher(apiClientHeaderKey)
755             .matches());
756   }
757 
758   @Test
getProcessorExceptionTest2()759   public void getProcessorExceptionTest2() throws Exception {
760     ApiException exception =
761         ApiExceptionFactory.createException(
762             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
763     mockService.addException(exception);
764 
765     try {
766       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
767       client.getProcessor(name);
768       Assert.fail("No exception raised");
769     } catch (InvalidArgumentException e) {
770       // Expected exception.
771     }
772   }
773 
774   @Test
trainProcessorVersionTest()775   public void trainProcessorVersionTest() throws Exception {
776     TrainProcessorVersionResponse expectedResponse =
777         TrainProcessorVersionResponse.newBuilder()
778             .setProcessorVersion("processorVersion-1941143578")
779             .build();
780     Operation resultOperation =
781         Operation.newBuilder()
782             .setName("trainProcessorVersionTest")
783             .setDone(true)
784             .setResponse(Any.pack(expectedResponse))
785             .build();
786     mockService.addResponse(resultOperation);
787 
788     ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
789     ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
790 
791     TrainProcessorVersionResponse actualResponse =
792         client.trainProcessorVersionAsync(parent, processorVersion).get();
793     Assert.assertEquals(expectedResponse, actualResponse);
794 
795     List<String> actualRequests = mockService.getRequestPaths();
796     Assert.assertEquals(1, actualRequests.size());
797 
798     String apiClientHeaderKey =
799         mockService
800             .getRequestHeaders()
801             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
802             .iterator()
803             .next();
804     Assert.assertTrue(
805         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
806             .matcher(apiClientHeaderKey)
807             .matches());
808   }
809 
810   @Test
trainProcessorVersionExceptionTest()811   public void trainProcessorVersionExceptionTest() throws Exception {
812     ApiException exception =
813         ApiExceptionFactory.createException(
814             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
815     mockService.addException(exception);
816 
817     try {
818       ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
819       ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
820       client.trainProcessorVersionAsync(parent, processorVersion).get();
821       Assert.fail("No exception raised");
822     } catch (ExecutionException e) {
823     }
824   }
825 
826   @Test
trainProcessorVersionTest2()827   public void trainProcessorVersionTest2() throws Exception {
828     TrainProcessorVersionResponse expectedResponse =
829         TrainProcessorVersionResponse.newBuilder()
830             .setProcessorVersion("processorVersion-1941143578")
831             .build();
832     Operation resultOperation =
833         Operation.newBuilder()
834             .setName("trainProcessorVersionTest")
835             .setDone(true)
836             .setResponse(Any.pack(expectedResponse))
837             .build();
838     mockService.addResponse(resultOperation);
839 
840     String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
841     ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
842 
843     TrainProcessorVersionResponse actualResponse =
844         client.trainProcessorVersionAsync(parent, processorVersion).get();
845     Assert.assertEquals(expectedResponse, actualResponse);
846 
847     List<String> actualRequests = mockService.getRequestPaths();
848     Assert.assertEquals(1, actualRequests.size());
849 
850     String apiClientHeaderKey =
851         mockService
852             .getRequestHeaders()
853             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
854             .iterator()
855             .next();
856     Assert.assertTrue(
857         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
858             .matcher(apiClientHeaderKey)
859             .matches());
860   }
861 
862   @Test
trainProcessorVersionExceptionTest2()863   public void trainProcessorVersionExceptionTest2() throws Exception {
864     ApiException exception =
865         ApiExceptionFactory.createException(
866             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
867     mockService.addException(exception);
868 
869     try {
870       String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
871       ProcessorVersion processorVersion = ProcessorVersion.newBuilder().build();
872       client.trainProcessorVersionAsync(parent, processorVersion).get();
873       Assert.fail("No exception raised");
874     } catch (ExecutionException e) {
875     }
876   }
877 
878   @Test
getProcessorVersionTest()879   public void getProcessorVersionTest() throws Exception {
880     ProcessorVersion expectedResponse =
881         ProcessorVersion.newBuilder()
882             .setName(
883                 ProcessorVersionName.of(
884                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
885                     .toString())
886             .setDisplayName("displayName1714148973")
887             .setDocumentSchema(DocumentSchema.newBuilder().build())
888             .setCreateTime(Timestamp.newBuilder().build())
889             .setLatestEvaluation(EvaluationReference.newBuilder().build())
890             .setKmsKeyName("kmsKeyName412586233")
891             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
892             .setGoogleManaged(true)
893             .setDeprecationInfo(ProcessorVersion.DeprecationInfo.newBuilder().build())
894             .build();
895     mockService.addResponse(expectedResponse);
896 
897     ProcessorVersionName name =
898         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
899 
900     ProcessorVersion actualResponse = client.getProcessorVersion(name);
901     Assert.assertEquals(expectedResponse, actualResponse);
902 
903     List<String> actualRequests = mockService.getRequestPaths();
904     Assert.assertEquals(1, actualRequests.size());
905 
906     String apiClientHeaderKey =
907         mockService
908             .getRequestHeaders()
909             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
910             .iterator()
911             .next();
912     Assert.assertTrue(
913         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
914             .matcher(apiClientHeaderKey)
915             .matches());
916   }
917 
918   @Test
getProcessorVersionExceptionTest()919   public void getProcessorVersionExceptionTest() throws Exception {
920     ApiException exception =
921         ApiExceptionFactory.createException(
922             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
923     mockService.addException(exception);
924 
925     try {
926       ProcessorVersionName name =
927           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
928       client.getProcessorVersion(name);
929       Assert.fail("No exception raised");
930     } catch (InvalidArgumentException e) {
931       // Expected exception.
932     }
933   }
934 
935   @Test
getProcessorVersionTest2()936   public void getProcessorVersionTest2() throws Exception {
937     ProcessorVersion expectedResponse =
938         ProcessorVersion.newBuilder()
939             .setName(
940                 ProcessorVersionName.of(
941                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
942                     .toString())
943             .setDisplayName("displayName1714148973")
944             .setDocumentSchema(DocumentSchema.newBuilder().build())
945             .setCreateTime(Timestamp.newBuilder().build())
946             .setLatestEvaluation(EvaluationReference.newBuilder().build())
947             .setKmsKeyName("kmsKeyName412586233")
948             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
949             .setGoogleManaged(true)
950             .setDeprecationInfo(ProcessorVersion.DeprecationInfo.newBuilder().build())
951             .build();
952     mockService.addResponse(expectedResponse);
953 
954     String name =
955         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
956 
957     ProcessorVersion actualResponse = client.getProcessorVersion(name);
958     Assert.assertEquals(expectedResponse, actualResponse);
959 
960     List<String> actualRequests = mockService.getRequestPaths();
961     Assert.assertEquals(1, actualRequests.size());
962 
963     String apiClientHeaderKey =
964         mockService
965             .getRequestHeaders()
966             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
967             .iterator()
968             .next();
969     Assert.assertTrue(
970         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
971             .matcher(apiClientHeaderKey)
972             .matches());
973   }
974 
975   @Test
getProcessorVersionExceptionTest2()976   public void getProcessorVersionExceptionTest2() throws Exception {
977     ApiException exception =
978         ApiExceptionFactory.createException(
979             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
980     mockService.addException(exception);
981 
982     try {
983       String name =
984           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
985       client.getProcessorVersion(name);
986       Assert.fail("No exception raised");
987     } catch (InvalidArgumentException e) {
988       // Expected exception.
989     }
990   }
991 
992   @Test
listProcessorVersionsTest()993   public void listProcessorVersionsTest() throws Exception {
994     ProcessorVersion responsesElement = ProcessorVersion.newBuilder().build();
995     ListProcessorVersionsResponse expectedResponse =
996         ListProcessorVersionsResponse.newBuilder()
997             .setNextPageToken("")
998             .addAllProcessorVersions(Arrays.asList(responsesElement))
999             .build();
1000     mockService.addResponse(expectedResponse);
1001 
1002     ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1003 
1004     ListProcessorVersionsPagedResponse pagedListResponse = client.listProcessorVersions(parent);
1005 
1006     List<ProcessorVersion> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1007 
1008     Assert.assertEquals(1, resources.size());
1009     Assert.assertEquals(expectedResponse.getProcessorVersionsList().get(0), resources.get(0));
1010 
1011     List<String> actualRequests = mockService.getRequestPaths();
1012     Assert.assertEquals(1, actualRequests.size());
1013 
1014     String apiClientHeaderKey =
1015         mockService
1016             .getRequestHeaders()
1017             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1018             .iterator()
1019             .next();
1020     Assert.assertTrue(
1021         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1022             .matcher(apiClientHeaderKey)
1023             .matches());
1024   }
1025 
1026   @Test
listProcessorVersionsExceptionTest()1027   public void listProcessorVersionsExceptionTest() throws Exception {
1028     ApiException exception =
1029         ApiExceptionFactory.createException(
1030             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1031     mockService.addException(exception);
1032 
1033     try {
1034       ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1035       client.listProcessorVersions(parent);
1036       Assert.fail("No exception raised");
1037     } catch (InvalidArgumentException e) {
1038       // Expected exception.
1039     }
1040   }
1041 
1042   @Test
listProcessorVersionsTest2()1043   public void listProcessorVersionsTest2() throws Exception {
1044     ProcessorVersion responsesElement = ProcessorVersion.newBuilder().build();
1045     ListProcessorVersionsResponse expectedResponse =
1046         ListProcessorVersionsResponse.newBuilder()
1047             .setNextPageToken("")
1048             .addAllProcessorVersions(Arrays.asList(responsesElement))
1049             .build();
1050     mockService.addResponse(expectedResponse);
1051 
1052     String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
1053 
1054     ListProcessorVersionsPagedResponse pagedListResponse = client.listProcessorVersions(parent);
1055 
1056     List<ProcessorVersion> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1057 
1058     Assert.assertEquals(1, resources.size());
1059     Assert.assertEquals(expectedResponse.getProcessorVersionsList().get(0), resources.get(0));
1060 
1061     List<String> actualRequests = mockService.getRequestPaths();
1062     Assert.assertEquals(1, actualRequests.size());
1063 
1064     String apiClientHeaderKey =
1065         mockService
1066             .getRequestHeaders()
1067             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1068             .iterator()
1069             .next();
1070     Assert.assertTrue(
1071         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1072             .matcher(apiClientHeaderKey)
1073             .matches());
1074   }
1075 
1076   @Test
listProcessorVersionsExceptionTest2()1077   public void listProcessorVersionsExceptionTest2() throws Exception {
1078     ApiException exception =
1079         ApiExceptionFactory.createException(
1080             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1081     mockService.addException(exception);
1082 
1083     try {
1084       String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
1085       client.listProcessorVersions(parent);
1086       Assert.fail("No exception raised");
1087     } catch (InvalidArgumentException e) {
1088       // Expected exception.
1089     }
1090   }
1091 
1092   @Test
deleteProcessorVersionTest()1093   public void deleteProcessorVersionTest() throws Exception {
1094     Empty expectedResponse = Empty.newBuilder().build();
1095     Operation resultOperation =
1096         Operation.newBuilder()
1097             .setName("deleteProcessorVersionTest")
1098             .setDone(true)
1099             .setResponse(Any.pack(expectedResponse))
1100             .build();
1101     mockService.addResponse(resultOperation);
1102 
1103     ProcessorVersionName name =
1104         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1105 
1106     client.deleteProcessorVersionAsync(name).get();
1107 
1108     List<String> actualRequests = mockService.getRequestPaths();
1109     Assert.assertEquals(1, actualRequests.size());
1110 
1111     String apiClientHeaderKey =
1112         mockService
1113             .getRequestHeaders()
1114             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1115             .iterator()
1116             .next();
1117     Assert.assertTrue(
1118         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1119             .matcher(apiClientHeaderKey)
1120             .matches());
1121   }
1122 
1123   @Test
deleteProcessorVersionExceptionTest()1124   public void deleteProcessorVersionExceptionTest() throws Exception {
1125     ApiException exception =
1126         ApiExceptionFactory.createException(
1127             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1128     mockService.addException(exception);
1129 
1130     try {
1131       ProcessorVersionName name =
1132           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1133       client.deleteProcessorVersionAsync(name).get();
1134       Assert.fail("No exception raised");
1135     } catch (ExecutionException e) {
1136     }
1137   }
1138 
1139   @Test
deleteProcessorVersionTest2()1140   public void deleteProcessorVersionTest2() throws Exception {
1141     Empty expectedResponse = Empty.newBuilder().build();
1142     Operation resultOperation =
1143         Operation.newBuilder()
1144             .setName("deleteProcessorVersionTest")
1145             .setDone(true)
1146             .setResponse(Any.pack(expectedResponse))
1147             .build();
1148     mockService.addResponse(resultOperation);
1149 
1150     String name =
1151         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1152 
1153     client.deleteProcessorVersionAsync(name).get();
1154 
1155     List<String> actualRequests = mockService.getRequestPaths();
1156     Assert.assertEquals(1, actualRequests.size());
1157 
1158     String apiClientHeaderKey =
1159         mockService
1160             .getRequestHeaders()
1161             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1162             .iterator()
1163             .next();
1164     Assert.assertTrue(
1165         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1166             .matcher(apiClientHeaderKey)
1167             .matches());
1168   }
1169 
1170   @Test
deleteProcessorVersionExceptionTest2()1171   public void deleteProcessorVersionExceptionTest2() throws Exception {
1172     ApiException exception =
1173         ApiExceptionFactory.createException(
1174             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1175     mockService.addException(exception);
1176 
1177     try {
1178       String name =
1179           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1180       client.deleteProcessorVersionAsync(name).get();
1181       Assert.fail("No exception raised");
1182     } catch (ExecutionException e) {
1183     }
1184   }
1185 
1186   @Test
deployProcessorVersionTest()1187   public void deployProcessorVersionTest() throws Exception {
1188     DeployProcessorVersionResponse expectedResponse =
1189         DeployProcessorVersionResponse.newBuilder().build();
1190     Operation resultOperation =
1191         Operation.newBuilder()
1192             .setName("deployProcessorVersionTest")
1193             .setDone(true)
1194             .setResponse(Any.pack(expectedResponse))
1195             .build();
1196     mockService.addResponse(resultOperation);
1197 
1198     ProcessorVersionName name =
1199         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1200 
1201     DeployProcessorVersionResponse actualResponse = client.deployProcessorVersionAsync(name).get();
1202     Assert.assertEquals(expectedResponse, actualResponse);
1203 
1204     List<String> actualRequests = mockService.getRequestPaths();
1205     Assert.assertEquals(1, actualRequests.size());
1206 
1207     String apiClientHeaderKey =
1208         mockService
1209             .getRequestHeaders()
1210             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1211             .iterator()
1212             .next();
1213     Assert.assertTrue(
1214         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1215             .matcher(apiClientHeaderKey)
1216             .matches());
1217   }
1218 
1219   @Test
deployProcessorVersionExceptionTest()1220   public void deployProcessorVersionExceptionTest() throws Exception {
1221     ApiException exception =
1222         ApiExceptionFactory.createException(
1223             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1224     mockService.addException(exception);
1225 
1226     try {
1227       ProcessorVersionName name =
1228           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1229       client.deployProcessorVersionAsync(name).get();
1230       Assert.fail("No exception raised");
1231     } catch (ExecutionException e) {
1232     }
1233   }
1234 
1235   @Test
deployProcessorVersionTest2()1236   public void deployProcessorVersionTest2() throws Exception {
1237     DeployProcessorVersionResponse expectedResponse =
1238         DeployProcessorVersionResponse.newBuilder().build();
1239     Operation resultOperation =
1240         Operation.newBuilder()
1241             .setName("deployProcessorVersionTest")
1242             .setDone(true)
1243             .setResponse(Any.pack(expectedResponse))
1244             .build();
1245     mockService.addResponse(resultOperation);
1246 
1247     String name =
1248         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1249 
1250     DeployProcessorVersionResponse actualResponse = client.deployProcessorVersionAsync(name).get();
1251     Assert.assertEquals(expectedResponse, actualResponse);
1252 
1253     List<String> actualRequests = mockService.getRequestPaths();
1254     Assert.assertEquals(1, actualRequests.size());
1255 
1256     String apiClientHeaderKey =
1257         mockService
1258             .getRequestHeaders()
1259             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1260             .iterator()
1261             .next();
1262     Assert.assertTrue(
1263         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1264             .matcher(apiClientHeaderKey)
1265             .matches());
1266   }
1267 
1268   @Test
deployProcessorVersionExceptionTest2()1269   public void deployProcessorVersionExceptionTest2() throws Exception {
1270     ApiException exception =
1271         ApiExceptionFactory.createException(
1272             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1273     mockService.addException(exception);
1274 
1275     try {
1276       String name =
1277           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1278       client.deployProcessorVersionAsync(name).get();
1279       Assert.fail("No exception raised");
1280     } catch (ExecutionException e) {
1281     }
1282   }
1283 
1284   @Test
undeployProcessorVersionTest()1285   public void undeployProcessorVersionTest() throws Exception {
1286     UndeployProcessorVersionResponse expectedResponse =
1287         UndeployProcessorVersionResponse.newBuilder().build();
1288     Operation resultOperation =
1289         Operation.newBuilder()
1290             .setName("undeployProcessorVersionTest")
1291             .setDone(true)
1292             .setResponse(Any.pack(expectedResponse))
1293             .build();
1294     mockService.addResponse(resultOperation);
1295 
1296     ProcessorVersionName name =
1297         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1298 
1299     UndeployProcessorVersionResponse actualResponse =
1300         client.undeployProcessorVersionAsync(name).get();
1301     Assert.assertEquals(expectedResponse, actualResponse);
1302 
1303     List<String> actualRequests = mockService.getRequestPaths();
1304     Assert.assertEquals(1, actualRequests.size());
1305 
1306     String apiClientHeaderKey =
1307         mockService
1308             .getRequestHeaders()
1309             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1310             .iterator()
1311             .next();
1312     Assert.assertTrue(
1313         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1314             .matcher(apiClientHeaderKey)
1315             .matches());
1316   }
1317 
1318   @Test
undeployProcessorVersionExceptionTest()1319   public void undeployProcessorVersionExceptionTest() throws Exception {
1320     ApiException exception =
1321         ApiExceptionFactory.createException(
1322             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1323     mockService.addException(exception);
1324 
1325     try {
1326       ProcessorVersionName name =
1327           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1328       client.undeployProcessorVersionAsync(name).get();
1329       Assert.fail("No exception raised");
1330     } catch (ExecutionException e) {
1331     }
1332   }
1333 
1334   @Test
undeployProcessorVersionTest2()1335   public void undeployProcessorVersionTest2() throws Exception {
1336     UndeployProcessorVersionResponse expectedResponse =
1337         UndeployProcessorVersionResponse.newBuilder().build();
1338     Operation resultOperation =
1339         Operation.newBuilder()
1340             .setName("undeployProcessorVersionTest")
1341             .setDone(true)
1342             .setResponse(Any.pack(expectedResponse))
1343             .build();
1344     mockService.addResponse(resultOperation);
1345 
1346     String name =
1347         "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1348 
1349     UndeployProcessorVersionResponse actualResponse =
1350         client.undeployProcessorVersionAsync(name).get();
1351     Assert.assertEquals(expectedResponse, actualResponse);
1352 
1353     List<String> actualRequests = mockService.getRequestPaths();
1354     Assert.assertEquals(1, actualRequests.size());
1355 
1356     String apiClientHeaderKey =
1357         mockService
1358             .getRequestHeaders()
1359             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1360             .iterator()
1361             .next();
1362     Assert.assertTrue(
1363         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1364             .matcher(apiClientHeaderKey)
1365             .matches());
1366   }
1367 
1368   @Test
undeployProcessorVersionExceptionTest2()1369   public void undeployProcessorVersionExceptionTest2() throws Exception {
1370     ApiException exception =
1371         ApiExceptionFactory.createException(
1372             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1373     mockService.addException(exception);
1374 
1375     try {
1376       String name =
1377           "projects/project-1178/locations/location-1178/processors/processor-1178/processorVersions/processorVersion-1178";
1378       client.undeployProcessorVersionAsync(name).get();
1379       Assert.fail("No exception raised");
1380     } catch (ExecutionException e) {
1381     }
1382   }
1383 
1384   @Test
createProcessorTest()1385   public void createProcessorTest() throws Exception {
1386     Processor expectedResponse =
1387         Processor.newBuilder()
1388             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1389             .setType("type3575610")
1390             .setDisplayName("displayName1714148973")
1391             .setDefaultProcessorVersion(
1392                 ProcessorVersionName.of(
1393                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1394                     .toString())
1395             .setProcessEndpoint("processEndpoint-891502300")
1396             .setCreateTime(Timestamp.newBuilder().build())
1397             .setKmsKeyName("kmsKeyName412586233")
1398             .build();
1399     mockService.addResponse(expectedResponse);
1400 
1401     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1402     Processor processor = Processor.newBuilder().build();
1403 
1404     Processor actualResponse = client.createProcessor(parent, processor);
1405     Assert.assertEquals(expectedResponse, actualResponse);
1406 
1407     List<String> actualRequests = mockService.getRequestPaths();
1408     Assert.assertEquals(1, actualRequests.size());
1409 
1410     String apiClientHeaderKey =
1411         mockService
1412             .getRequestHeaders()
1413             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1414             .iterator()
1415             .next();
1416     Assert.assertTrue(
1417         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1418             .matcher(apiClientHeaderKey)
1419             .matches());
1420   }
1421 
1422   @Test
createProcessorExceptionTest()1423   public void createProcessorExceptionTest() throws Exception {
1424     ApiException exception =
1425         ApiExceptionFactory.createException(
1426             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1427     mockService.addException(exception);
1428 
1429     try {
1430       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1431       Processor processor = Processor.newBuilder().build();
1432       client.createProcessor(parent, processor);
1433       Assert.fail("No exception raised");
1434     } catch (InvalidArgumentException e) {
1435       // Expected exception.
1436     }
1437   }
1438 
1439   @Test
createProcessorTest2()1440   public void createProcessorTest2() throws Exception {
1441     Processor expectedResponse =
1442         Processor.newBuilder()
1443             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1444             .setType("type3575610")
1445             .setDisplayName("displayName1714148973")
1446             .setDefaultProcessorVersion(
1447                 ProcessorVersionName.of(
1448                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1449                     .toString())
1450             .setProcessEndpoint("processEndpoint-891502300")
1451             .setCreateTime(Timestamp.newBuilder().build())
1452             .setKmsKeyName("kmsKeyName412586233")
1453             .build();
1454     mockService.addResponse(expectedResponse);
1455 
1456     String parent = "projects/project-5833/locations/location-5833";
1457     Processor processor = Processor.newBuilder().build();
1458 
1459     Processor actualResponse = client.createProcessor(parent, processor);
1460     Assert.assertEquals(expectedResponse, actualResponse);
1461 
1462     List<String> actualRequests = mockService.getRequestPaths();
1463     Assert.assertEquals(1, actualRequests.size());
1464 
1465     String apiClientHeaderKey =
1466         mockService
1467             .getRequestHeaders()
1468             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1469             .iterator()
1470             .next();
1471     Assert.assertTrue(
1472         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1473             .matcher(apiClientHeaderKey)
1474             .matches());
1475   }
1476 
1477   @Test
createProcessorExceptionTest2()1478   public void createProcessorExceptionTest2() throws Exception {
1479     ApiException exception =
1480         ApiExceptionFactory.createException(
1481             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1482     mockService.addException(exception);
1483 
1484     try {
1485       String parent = "projects/project-5833/locations/location-5833";
1486       Processor processor = Processor.newBuilder().build();
1487       client.createProcessor(parent, processor);
1488       Assert.fail("No exception raised");
1489     } catch (InvalidArgumentException e) {
1490       // Expected exception.
1491     }
1492   }
1493 
1494   @Test
deleteProcessorTest()1495   public void deleteProcessorTest() throws Exception {
1496     Empty expectedResponse = Empty.newBuilder().build();
1497     Operation resultOperation =
1498         Operation.newBuilder()
1499             .setName("deleteProcessorTest")
1500             .setDone(true)
1501             .setResponse(Any.pack(expectedResponse))
1502             .build();
1503     mockService.addResponse(resultOperation);
1504 
1505     ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1506 
1507     client.deleteProcessorAsync(name).get();
1508 
1509     List<String> actualRequests = mockService.getRequestPaths();
1510     Assert.assertEquals(1, actualRequests.size());
1511 
1512     String apiClientHeaderKey =
1513         mockService
1514             .getRequestHeaders()
1515             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1516             .iterator()
1517             .next();
1518     Assert.assertTrue(
1519         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1520             .matcher(apiClientHeaderKey)
1521             .matches());
1522   }
1523 
1524   @Test
deleteProcessorExceptionTest()1525   public void deleteProcessorExceptionTest() throws Exception {
1526     ApiException exception =
1527         ApiExceptionFactory.createException(
1528             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1529     mockService.addException(exception);
1530 
1531     try {
1532       ProcessorName name = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1533       client.deleteProcessorAsync(name).get();
1534       Assert.fail("No exception raised");
1535     } catch (ExecutionException e) {
1536     }
1537   }
1538 
1539   @Test
deleteProcessorTest2()1540   public void deleteProcessorTest2() throws Exception {
1541     Empty expectedResponse = Empty.newBuilder().build();
1542     Operation resultOperation =
1543         Operation.newBuilder()
1544             .setName("deleteProcessorTest")
1545             .setDone(true)
1546             .setResponse(Any.pack(expectedResponse))
1547             .build();
1548     mockService.addResponse(resultOperation);
1549 
1550     String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
1551 
1552     client.deleteProcessorAsync(name).get();
1553 
1554     List<String> actualRequests = mockService.getRequestPaths();
1555     Assert.assertEquals(1, actualRequests.size());
1556 
1557     String apiClientHeaderKey =
1558         mockService
1559             .getRequestHeaders()
1560             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1561             .iterator()
1562             .next();
1563     Assert.assertTrue(
1564         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1565             .matcher(apiClientHeaderKey)
1566             .matches());
1567   }
1568 
1569   @Test
deleteProcessorExceptionTest2()1570   public void deleteProcessorExceptionTest2() throws Exception {
1571     ApiException exception =
1572         ApiExceptionFactory.createException(
1573             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1574     mockService.addException(exception);
1575 
1576     try {
1577       String name = "projects/project-5167/locations/location-5167/processors/processor-5167";
1578       client.deleteProcessorAsync(name).get();
1579       Assert.fail("No exception raised");
1580     } catch (ExecutionException e) {
1581     }
1582   }
1583 
1584   @Test
enableProcessorTest()1585   public void enableProcessorTest() throws Exception {
1586     EnableProcessorResponse expectedResponse = EnableProcessorResponse.newBuilder().build();
1587     Operation resultOperation =
1588         Operation.newBuilder()
1589             .setName("enableProcessorTest")
1590             .setDone(true)
1591             .setResponse(Any.pack(expectedResponse))
1592             .build();
1593     mockService.addResponse(resultOperation);
1594 
1595     EnableProcessorRequest request =
1596         EnableProcessorRequest.newBuilder()
1597             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1598             .build();
1599 
1600     EnableProcessorResponse actualResponse = client.enableProcessorAsync(request).get();
1601     Assert.assertEquals(expectedResponse, actualResponse);
1602 
1603     List<String> actualRequests = mockService.getRequestPaths();
1604     Assert.assertEquals(1, actualRequests.size());
1605 
1606     String apiClientHeaderKey =
1607         mockService
1608             .getRequestHeaders()
1609             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1610             .iterator()
1611             .next();
1612     Assert.assertTrue(
1613         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1614             .matcher(apiClientHeaderKey)
1615             .matches());
1616   }
1617 
1618   @Test
enableProcessorExceptionTest()1619   public void enableProcessorExceptionTest() throws Exception {
1620     ApiException exception =
1621         ApiExceptionFactory.createException(
1622             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1623     mockService.addException(exception);
1624 
1625     try {
1626       EnableProcessorRequest request =
1627           EnableProcessorRequest.newBuilder()
1628               .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1629               .build();
1630       client.enableProcessorAsync(request).get();
1631       Assert.fail("No exception raised");
1632     } catch (ExecutionException e) {
1633     }
1634   }
1635 
1636   @Test
disableProcessorTest()1637   public void disableProcessorTest() throws Exception {
1638     DisableProcessorResponse expectedResponse = DisableProcessorResponse.newBuilder().build();
1639     Operation resultOperation =
1640         Operation.newBuilder()
1641             .setName("disableProcessorTest")
1642             .setDone(true)
1643             .setResponse(Any.pack(expectedResponse))
1644             .build();
1645     mockService.addResponse(resultOperation);
1646 
1647     DisableProcessorRequest request =
1648         DisableProcessorRequest.newBuilder()
1649             .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1650             .build();
1651 
1652     DisableProcessorResponse actualResponse = client.disableProcessorAsync(request).get();
1653     Assert.assertEquals(expectedResponse, actualResponse);
1654 
1655     List<String> actualRequests = mockService.getRequestPaths();
1656     Assert.assertEquals(1, actualRequests.size());
1657 
1658     String apiClientHeaderKey =
1659         mockService
1660             .getRequestHeaders()
1661             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1662             .iterator()
1663             .next();
1664     Assert.assertTrue(
1665         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1666             .matcher(apiClientHeaderKey)
1667             .matches());
1668   }
1669 
1670   @Test
disableProcessorExceptionTest()1671   public void disableProcessorExceptionTest() throws Exception {
1672     ApiException exception =
1673         ApiExceptionFactory.createException(
1674             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1675     mockService.addException(exception);
1676 
1677     try {
1678       DisableProcessorRequest request =
1679           DisableProcessorRequest.newBuilder()
1680               .setName(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1681               .build();
1682       client.disableProcessorAsync(request).get();
1683       Assert.fail("No exception raised");
1684     } catch (ExecutionException e) {
1685     }
1686   }
1687 
1688   @Test
setDefaultProcessorVersionTest()1689   public void setDefaultProcessorVersionTest() throws Exception {
1690     SetDefaultProcessorVersionResponse expectedResponse =
1691         SetDefaultProcessorVersionResponse.newBuilder().build();
1692     Operation resultOperation =
1693         Operation.newBuilder()
1694             .setName("setDefaultProcessorVersionTest")
1695             .setDone(true)
1696             .setResponse(Any.pack(expectedResponse))
1697             .build();
1698     mockService.addResponse(resultOperation);
1699 
1700     SetDefaultProcessorVersionRequest request =
1701         SetDefaultProcessorVersionRequest.newBuilder()
1702             .setProcessor(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1703             .setDefaultProcessorVersion(
1704                 ProcessorVersionName.of(
1705                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1706                     .toString())
1707             .build();
1708 
1709     SetDefaultProcessorVersionResponse actualResponse =
1710         client.setDefaultProcessorVersionAsync(request).get();
1711     Assert.assertEquals(expectedResponse, actualResponse);
1712 
1713     List<String> actualRequests = mockService.getRequestPaths();
1714     Assert.assertEquals(1, actualRequests.size());
1715 
1716     String apiClientHeaderKey =
1717         mockService
1718             .getRequestHeaders()
1719             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1720             .iterator()
1721             .next();
1722     Assert.assertTrue(
1723         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1724             .matcher(apiClientHeaderKey)
1725             .matches());
1726   }
1727 
1728   @Test
setDefaultProcessorVersionExceptionTest()1729   public void setDefaultProcessorVersionExceptionTest() throws Exception {
1730     ApiException exception =
1731         ApiExceptionFactory.createException(
1732             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1733     mockService.addException(exception);
1734 
1735     try {
1736       SetDefaultProcessorVersionRequest request =
1737           SetDefaultProcessorVersionRequest.newBuilder()
1738               .setProcessor(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
1739               .setDefaultProcessorVersion(
1740                   ProcessorVersionName.of(
1741                           "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
1742                       .toString())
1743               .build();
1744       client.setDefaultProcessorVersionAsync(request).get();
1745       Assert.fail("No exception raised");
1746     } catch (ExecutionException e) {
1747     }
1748   }
1749 
1750   @Test
reviewDocumentTest()1751   public void reviewDocumentTest() throws Exception {
1752     ReviewDocumentResponse expectedResponse =
1753         ReviewDocumentResponse.newBuilder()
1754             .setGcsDestination("gcsDestination-1612392329")
1755             .setRejectionReason("rejectionReason1485905837")
1756             .build();
1757     Operation resultOperation =
1758         Operation.newBuilder()
1759             .setName("reviewDocumentTest")
1760             .setDone(true)
1761             .setResponse(Any.pack(expectedResponse))
1762             .build();
1763     mockService.addResponse(resultOperation);
1764 
1765     HumanReviewConfigName humanReviewConfig =
1766         HumanReviewConfigName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1767 
1768     ReviewDocumentResponse actualResponse = client.reviewDocumentAsync(humanReviewConfig).get();
1769     Assert.assertEquals(expectedResponse, actualResponse);
1770 
1771     List<String> actualRequests = mockService.getRequestPaths();
1772     Assert.assertEquals(1, actualRequests.size());
1773 
1774     String apiClientHeaderKey =
1775         mockService
1776             .getRequestHeaders()
1777             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1778             .iterator()
1779             .next();
1780     Assert.assertTrue(
1781         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1782             .matcher(apiClientHeaderKey)
1783             .matches());
1784   }
1785 
1786   @Test
reviewDocumentExceptionTest()1787   public void reviewDocumentExceptionTest() throws Exception {
1788     ApiException exception =
1789         ApiExceptionFactory.createException(
1790             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1791     mockService.addException(exception);
1792 
1793     try {
1794       HumanReviewConfigName humanReviewConfig =
1795           HumanReviewConfigName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
1796       client.reviewDocumentAsync(humanReviewConfig).get();
1797       Assert.fail("No exception raised");
1798     } catch (ExecutionException e) {
1799     }
1800   }
1801 
1802   @Test
reviewDocumentTest2()1803   public void reviewDocumentTest2() throws Exception {
1804     ReviewDocumentResponse expectedResponse =
1805         ReviewDocumentResponse.newBuilder()
1806             .setGcsDestination("gcsDestination-1612392329")
1807             .setRejectionReason("rejectionReason1485905837")
1808             .build();
1809     Operation resultOperation =
1810         Operation.newBuilder()
1811             .setName("reviewDocumentTest")
1812             .setDone(true)
1813             .setResponse(Any.pack(expectedResponse))
1814             .build();
1815     mockService.addResponse(resultOperation);
1816 
1817     String humanReviewConfig =
1818         "projects/project-1917/locations/location-1917/processors/processor-1917/humanReviewConfig";
1819 
1820     ReviewDocumentResponse actualResponse = client.reviewDocumentAsync(humanReviewConfig).get();
1821     Assert.assertEquals(expectedResponse, actualResponse);
1822 
1823     List<String> actualRequests = mockService.getRequestPaths();
1824     Assert.assertEquals(1, actualRequests.size());
1825 
1826     String apiClientHeaderKey =
1827         mockService
1828             .getRequestHeaders()
1829             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1830             .iterator()
1831             .next();
1832     Assert.assertTrue(
1833         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1834             .matcher(apiClientHeaderKey)
1835             .matches());
1836   }
1837 
1838   @Test
reviewDocumentExceptionTest2()1839   public void reviewDocumentExceptionTest2() throws Exception {
1840     ApiException exception =
1841         ApiExceptionFactory.createException(
1842             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1843     mockService.addException(exception);
1844 
1845     try {
1846       String humanReviewConfig =
1847           "projects/project-1917/locations/location-1917/processors/processor-1917/humanReviewConfig";
1848       client.reviewDocumentAsync(humanReviewConfig).get();
1849       Assert.fail("No exception raised");
1850     } catch (ExecutionException e) {
1851     }
1852   }
1853 
1854   @Test
evaluateProcessorVersionTest()1855   public void evaluateProcessorVersionTest() throws Exception {
1856     EvaluateProcessorVersionResponse expectedResponse =
1857         EvaluateProcessorVersionResponse.newBuilder().setEvaluation("evaluation858523452").build();
1858     Operation resultOperation =
1859         Operation.newBuilder()
1860             .setName("evaluateProcessorVersionTest")
1861             .setDone(true)
1862             .setResponse(Any.pack(expectedResponse))
1863             .build();
1864     mockService.addResponse(resultOperation);
1865 
1866     ProcessorVersionName processorVersion =
1867         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1868 
1869     EvaluateProcessorVersionResponse actualResponse =
1870         client.evaluateProcessorVersionAsync(processorVersion).get();
1871     Assert.assertEquals(expectedResponse, actualResponse);
1872 
1873     List<String> actualRequests = mockService.getRequestPaths();
1874     Assert.assertEquals(1, actualRequests.size());
1875 
1876     String apiClientHeaderKey =
1877         mockService
1878             .getRequestHeaders()
1879             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1880             .iterator()
1881             .next();
1882     Assert.assertTrue(
1883         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1884             .matcher(apiClientHeaderKey)
1885             .matches());
1886   }
1887 
1888   @Test
evaluateProcessorVersionExceptionTest()1889   public void evaluateProcessorVersionExceptionTest() throws Exception {
1890     ApiException exception =
1891         ApiExceptionFactory.createException(
1892             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1893     mockService.addException(exception);
1894 
1895     try {
1896       ProcessorVersionName processorVersion =
1897           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
1898       client.evaluateProcessorVersionAsync(processorVersion).get();
1899       Assert.fail("No exception raised");
1900     } catch (ExecutionException e) {
1901     }
1902   }
1903 
1904   @Test
evaluateProcessorVersionTest2()1905   public void evaluateProcessorVersionTest2() throws Exception {
1906     EvaluateProcessorVersionResponse expectedResponse =
1907         EvaluateProcessorVersionResponse.newBuilder().setEvaluation("evaluation858523452").build();
1908     Operation resultOperation =
1909         Operation.newBuilder()
1910             .setName("evaluateProcessorVersionTest")
1911             .setDone(true)
1912             .setResponse(Any.pack(expectedResponse))
1913             .build();
1914     mockService.addResponse(resultOperation);
1915 
1916     String processorVersion =
1917         "projects/project-7729/locations/location-7729/processors/processor-7729/processorVersions/processorVersion-7729";
1918 
1919     EvaluateProcessorVersionResponse actualResponse =
1920         client.evaluateProcessorVersionAsync(processorVersion).get();
1921     Assert.assertEquals(expectedResponse, actualResponse);
1922 
1923     List<String> actualRequests = mockService.getRequestPaths();
1924     Assert.assertEquals(1, actualRequests.size());
1925 
1926     String apiClientHeaderKey =
1927         mockService
1928             .getRequestHeaders()
1929             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1930             .iterator()
1931             .next();
1932     Assert.assertTrue(
1933         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1934             .matcher(apiClientHeaderKey)
1935             .matches());
1936   }
1937 
1938   @Test
evaluateProcessorVersionExceptionTest2()1939   public void evaluateProcessorVersionExceptionTest2() throws Exception {
1940     ApiException exception =
1941         ApiExceptionFactory.createException(
1942             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1943     mockService.addException(exception);
1944 
1945     try {
1946       String processorVersion =
1947           "projects/project-7729/locations/location-7729/processors/processor-7729/processorVersions/processorVersion-7729";
1948       client.evaluateProcessorVersionAsync(processorVersion).get();
1949       Assert.fail("No exception raised");
1950     } catch (ExecutionException e) {
1951     }
1952   }
1953 
1954   @Test
getEvaluationTest()1955   public void getEvaluationTest() throws Exception {
1956     Evaluation expectedResponse =
1957         Evaluation.newBuilder()
1958             .setName(
1959                 EvaluationName.of(
1960                         "[PROJECT]",
1961                         "[LOCATION]",
1962                         "[PROCESSOR]",
1963                         "[PROCESSOR_VERSION]",
1964                         "[EVALUATION]")
1965                     .toString())
1966             .setCreateTime(Timestamp.newBuilder().build())
1967             .setDocumentCounters(Evaluation.Counters.newBuilder().build())
1968             .setAllEntitiesMetrics(Evaluation.MultiConfidenceMetrics.newBuilder().build())
1969             .putAllEntityMetrics(new HashMap<String, Evaluation.MultiConfidenceMetrics>())
1970             .setKmsKeyName("kmsKeyName412586233")
1971             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1972             .build();
1973     mockService.addResponse(expectedResponse);
1974 
1975     EvaluationName name =
1976         EvaluationName.of(
1977             "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]", "[EVALUATION]");
1978 
1979     Evaluation actualResponse = client.getEvaluation(name);
1980     Assert.assertEquals(expectedResponse, actualResponse);
1981 
1982     List<String> actualRequests = mockService.getRequestPaths();
1983     Assert.assertEquals(1, actualRequests.size());
1984 
1985     String apiClientHeaderKey =
1986         mockService
1987             .getRequestHeaders()
1988             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1989             .iterator()
1990             .next();
1991     Assert.assertTrue(
1992         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1993             .matcher(apiClientHeaderKey)
1994             .matches());
1995   }
1996 
1997   @Test
getEvaluationExceptionTest()1998   public void getEvaluationExceptionTest() throws Exception {
1999     ApiException exception =
2000         ApiExceptionFactory.createException(
2001             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2002     mockService.addException(exception);
2003 
2004     try {
2005       EvaluationName name =
2006           EvaluationName.of(
2007               "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]", "[EVALUATION]");
2008       client.getEvaluation(name);
2009       Assert.fail("No exception raised");
2010     } catch (InvalidArgumentException e) {
2011       // Expected exception.
2012     }
2013   }
2014 
2015   @Test
getEvaluationTest2()2016   public void getEvaluationTest2() throws Exception {
2017     Evaluation expectedResponse =
2018         Evaluation.newBuilder()
2019             .setName(
2020                 EvaluationName.of(
2021                         "[PROJECT]",
2022                         "[LOCATION]",
2023                         "[PROCESSOR]",
2024                         "[PROCESSOR_VERSION]",
2025                         "[EVALUATION]")
2026                     .toString())
2027             .setCreateTime(Timestamp.newBuilder().build())
2028             .setDocumentCounters(Evaluation.Counters.newBuilder().build())
2029             .setAllEntitiesMetrics(Evaluation.MultiConfidenceMetrics.newBuilder().build())
2030             .putAllEntityMetrics(new HashMap<String, Evaluation.MultiConfidenceMetrics>())
2031             .setKmsKeyName("kmsKeyName412586233")
2032             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2033             .build();
2034     mockService.addResponse(expectedResponse);
2035 
2036     String name =
2037         "projects/project-6701/locations/location-6701/processors/processor-6701/processorVersions/processorVersion-6701/evaluations/evaluation-6701";
2038 
2039     Evaluation actualResponse = client.getEvaluation(name);
2040     Assert.assertEquals(expectedResponse, actualResponse);
2041 
2042     List<String> actualRequests = mockService.getRequestPaths();
2043     Assert.assertEquals(1, actualRequests.size());
2044 
2045     String apiClientHeaderKey =
2046         mockService
2047             .getRequestHeaders()
2048             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2049             .iterator()
2050             .next();
2051     Assert.assertTrue(
2052         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2053             .matcher(apiClientHeaderKey)
2054             .matches());
2055   }
2056 
2057   @Test
getEvaluationExceptionTest2()2058   public void getEvaluationExceptionTest2() throws Exception {
2059     ApiException exception =
2060         ApiExceptionFactory.createException(
2061             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2062     mockService.addException(exception);
2063 
2064     try {
2065       String name =
2066           "projects/project-6701/locations/location-6701/processors/processor-6701/processorVersions/processorVersion-6701/evaluations/evaluation-6701";
2067       client.getEvaluation(name);
2068       Assert.fail("No exception raised");
2069     } catch (InvalidArgumentException e) {
2070       // Expected exception.
2071     }
2072   }
2073 
2074   @Test
listEvaluationsTest()2075   public void listEvaluationsTest() throws Exception {
2076     Evaluation responsesElement = Evaluation.newBuilder().build();
2077     ListEvaluationsResponse expectedResponse =
2078         ListEvaluationsResponse.newBuilder()
2079             .setNextPageToken("")
2080             .addAllEvaluations(Arrays.asList(responsesElement))
2081             .build();
2082     mockService.addResponse(expectedResponse);
2083 
2084     ProcessorVersionName parent =
2085         ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
2086 
2087     ListEvaluationsPagedResponse pagedListResponse = client.listEvaluations(parent);
2088 
2089     List<Evaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2090 
2091     Assert.assertEquals(1, resources.size());
2092     Assert.assertEquals(expectedResponse.getEvaluationsList().get(0), resources.get(0));
2093 
2094     List<String> actualRequests = mockService.getRequestPaths();
2095     Assert.assertEquals(1, actualRequests.size());
2096 
2097     String apiClientHeaderKey =
2098         mockService
2099             .getRequestHeaders()
2100             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2101             .iterator()
2102             .next();
2103     Assert.assertTrue(
2104         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2105             .matcher(apiClientHeaderKey)
2106             .matches());
2107   }
2108 
2109   @Test
listEvaluationsExceptionTest()2110   public void listEvaluationsExceptionTest() throws Exception {
2111     ApiException exception =
2112         ApiExceptionFactory.createException(
2113             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2114     mockService.addException(exception);
2115 
2116     try {
2117       ProcessorVersionName parent =
2118           ProcessorVersionName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]");
2119       client.listEvaluations(parent);
2120       Assert.fail("No exception raised");
2121     } catch (InvalidArgumentException e) {
2122       // Expected exception.
2123     }
2124   }
2125 
2126   @Test
listEvaluationsTest2()2127   public void listEvaluationsTest2() throws Exception {
2128     Evaluation responsesElement = Evaluation.newBuilder().build();
2129     ListEvaluationsResponse expectedResponse =
2130         ListEvaluationsResponse.newBuilder()
2131             .setNextPageToken("")
2132             .addAllEvaluations(Arrays.asList(responsesElement))
2133             .build();
2134     mockService.addResponse(expectedResponse);
2135 
2136     String parent =
2137         "projects/project-1781/locations/location-1781/processors/processor-1781/processorVersions/processorVersion-1781";
2138 
2139     ListEvaluationsPagedResponse pagedListResponse = client.listEvaluations(parent);
2140 
2141     List<Evaluation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2142 
2143     Assert.assertEquals(1, resources.size());
2144     Assert.assertEquals(expectedResponse.getEvaluationsList().get(0), resources.get(0));
2145 
2146     List<String> actualRequests = mockService.getRequestPaths();
2147     Assert.assertEquals(1, actualRequests.size());
2148 
2149     String apiClientHeaderKey =
2150         mockService
2151             .getRequestHeaders()
2152             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2153             .iterator()
2154             .next();
2155     Assert.assertTrue(
2156         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2157             .matcher(apiClientHeaderKey)
2158             .matches());
2159   }
2160 
2161   @Test
listEvaluationsExceptionTest2()2162   public void listEvaluationsExceptionTest2() throws Exception {
2163     ApiException exception =
2164         ApiExceptionFactory.createException(
2165             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2166     mockService.addException(exception);
2167 
2168     try {
2169       String parent =
2170           "projects/project-1781/locations/location-1781/processors/processor-1781/processorVersions/processorVersion-1781";
2171       client.listEvaluations(parent);
2172       Assert.fail("No exception raised");
2173     } catch (InvalidArgumentException e) {
2174       // Expected exception.
2175     }
2176   }
2177 
2178   @Test
importProcessorVersionTest()2179   public void importProcessorVersionTest() throws Exception {
2180     ImportProcessorVersionResponse expectedResponse =
2181         ImportProcessorVersionResponse.newBuilder()
2182             .setProcessorVersion(
2183                 ProcessorVersionName.of(
2184                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
2185                     .toString())
2186             .build();
2187     Operation resultOperation =
2188         Operation.newBuilder()
2189             .setName("importProcessorVersionTest")
2190             .setDone(true)
2191             .setResponse(Any.pack(expectedResponse))
2192             .build();
2193     mockService.addResponse(resultOperation);
2194 
2195     ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
2196 
2197     ImportProcessorVersionResponse actualResponse =
2198         client.importProcessorVersionAsync(parent).get();
2199     Assert.assertEquals(expectedResponse, actualResponse);
2200 
2201     List<String> actualRequests = mockService.getRequestPaths();
2202     Assert.assertEquals(1, actualRequests.size());
2203 
2204     String apiClientHeaderKey =
2205         mockService
2206             .getRequestHeaders()
2207             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2208             .iterator()
2209             .next();
2210     Assert.assertTrue(
2211         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2212             .matcher(apiClientHeaderKey)
2213             .matches());
2214   }
2215 
2216   @Test
importProcessorVersionExceptionTest()2217   public void importProcessorVersionExceptionTest() throws Exception {
2218     ApiException exception =
2219         ApiExceptionFactory.createException(
2220             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2221     mockService.addException(exception);
2222 
2223     try {
2224       ProcessorName parent = ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]");
2225       client.importProcessorVersionAsync(parent).get();
2226       Assert.fail("No exception raised");
2227     } catch (ExecutionException e) {
2228     }
2229   }
2230 
2231   @Test
importProcessorVersionTest2()2232   public void importProcessorVersionTest2() throws Exception {
2233     ImportProcessorVersionResponse expectedResponse =
2234         ImportProcessorVersionResponse.newBuilder()
2235             .setProcessorVersion(
2236                 ProcessorVersionName.of(
2237                         "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
2238                     .toString())
2239             .build();
2240     Operation resultOperation =
2241         Operation.newBuilder()
2242             .setName("importProcessorVersionTest")
2243             .setDone(true)
2244             .setResponse(Any.pack(expectedResponse))
2245             .build();
2246     mockService.addResponse(resultOperation);
2247 
2248     String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
2249 
2250     ImportProcessorVersionResponse actualResponse =
2251         client.importProcessorVersionAsync(parent).get();
2252     Assert.assertEquals(expectedResponse, actualResponse);
2253 
2254     List<String> actualRequests = mockService.getRequestPaths();
2255     Assert.assertEquals(1, actualRequests.size());
2256 
2257     String apiClientHeaderKey =
2258         mockService
2259             .getRequestHeaders()
2260             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2261             .iterator()
2262             .next();
2263     Assert.assertTrue(
2264         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2265             .matcher(apiClientHeaderKey)
2266             .matches());
2267   }
2268 
2269   @Test
importProcessorVersionExceptionTest2()2270   public void importProcessorVersionExceptionTest2() throws Exception {
2271     ApiException exception =
2272         ApiExceptionFactory.createException(
2273             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2274     mockService.addException(exception);
2275 
2276     try {
2277       String parent = "projects/project-3198/locations/location-3198/processors/processor-3198";
2278       client.importProcessorVersionAsync(parent).get();
2279       Assert.fail("No exception raised");
2280     } catch (ExecutionException e) {
2281     }
2282   }
2283 
2284   @Test
listLocationsTest()2285   public void listLocationsTest() throws Exception {
2286     Location responsesElement = Location.newBuilder().build();
2287     ListLocationsResponse expectedResponse =
2288         ListLocationsResponse.newBuilder()
2289             .setNextPageToken("")
2290             .addAllLocations(Arrays.asList(responsesElement))
2291             .build();
2292     mockService.addResponse(expectedResponse);
2293 
2294     ListLocationsRequest request =
2295         ListLocationsRequest.newBuilder()
2296             .setName("projects/project-3664")
2297             .setFilter("filter-1274492040")
2298             .setPageSize(883849137)
2299             .setPageToken("pageToken873572522")
2300             .build();
2301 
2302     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2303 
2304     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2305 
2306     Assert.assertEquals(1, resources.size());
2307     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2308 
2309     List<String> actualRequests = mockService.getRequestPaths();
2310     Assert.assertEquals(1, actualRequests.size());
2311 
2312     String apiClientHeaderKey =
2313         mockService
2314             .getRequestHeaders()
2315             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2316             .iterator()
2317             .next();
2318     Assert.assertTrue(
2319         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2320             .matcher(apiClientHeaderKey)
2321             .matches());
2322   }
2323 
2324   @Test
listLocationsExceptionTest()2325   public void listLocationsExceptionTest() throws Exception {
2326     ApiException exception =
2327         ApiExceptionFactory.createException(
2328             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2329     mockService.addException(exception);
2330 
2331     try {
2332       ListLocationsRequest request =
2333           ListLocationsRequest.newBuilder()
2334               .setName("projects/project-3664")
2335               .setFilter("filter-1274492040")
2336               .setPageSize(883849137)
2337               .setPageToken("pageToken873572522")
2338               .build();
2339       client.listLocations(request);
2340       Assert.fail("No exception raised");
2341     } catch (InvalidArgumentException e) {
2342       // Expected exception.
2343     }
2344   }
2345 
2346   @Test
getLocationTest()2347   public void getLocationTest() throws Exception {
2348     Location expectedResponse =
2349         Location.newBuilder()
2350             .setName("name3373707")
2351             .setLocationId("locationId1541836720")
2352             .setDisplayName("displayName1714148973")
2353             .putAllLabels(new HashMap<String, String>())
2354             .setMetadata(Any.newBuilder().build())
2355             .build();
2356     mockService.addResponse(expectedResponse);
2357 
2358     GetLocationRequest request =
2359         GetLocationRequest.newBuilder()
2360             .setName("projects/project-9062/locations/location-9062")
2361             .build();
2362 
2363     Location actualResponse = client.getLocation(request);
2364     Assert.assertEquals(expectedResponse, actualResponse);
2365 
2366     List<String> actualRequests = mockService.getRequestPaths();
2367     Assert.assertEquals(1, actualRequests.size());
2368 
2369     String apiClientHeaderKey =
2370         mockService
2371             .getRequestHeaders()
2372             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2373             .iterator()
2374             .next();
2375     Assert.assertTrue(
2376         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2377             .matcher(apiClientHeaderKey)
2378             .matches());
2379   }
2380 
2381   @Test
getLocationExceptionTest()2382   public void getLocationExceptionTest() throws Exception {
2383     ApiException exception =
2384         ApiExceptionFactory.createException(
2385             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2386     mockService.addException(exception);
2387 
2388     try {
2389       GetLocationRequest request =
2390           GetLocationRequest.newBuilder()
2391               .setName("projects/project-9062/locations/location-9062")
2392               .build();
2393       client.getLocation(request);
2394       Assert.fail("No exception raised");
2395     } catch (InvalidArgumentException e) {
2396       // Expected exception.
2397     }
2398   }
2399 }
2400