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