• 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.speech.v2;
18 
19 import static com.google.cloud.speech.v2.SpeechClient.ListCustomClassesPagedResponse;
20 import static com.google.cloud.speech.v2.SpeechClient.ListLocationsPagedResponse;
21 import static com.google.cloud.speech.v2.SpeechClient.ListPhraseSetsPagedResponse;
22 import static com.google.cloud.speech.v2.SpeechClient.ListRecognizersPagedResponse;
23 
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
26 import com.google.api.gax.httpjson.testing.MockHttpService;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.ApiException;
29 import com.google.api.gax.rpc.ApiExceptionFactory;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.api.gax.rpc.testing.FakeStatusCode;
33 import com.google.cloud.location.GetLocationRequest;
34 import com.google.cloud.location.ListLocationsRequest;
35 import com.google.cloud.location.ListLocationsResponse;
36 import com.google.cloud.location.Location;
37 import com.google.cloud.speech.v2.stub.HttpJsonSpeechStub;
38 import com.google.common.collect.Lists;
39 import com.google.longrunning.Operation;
40 import com.google.protobuf.Any;
41 import com.google.protobuf.ByteString;
42 import com.google.protobuf.Duration;
43 import com.google.protobuf.FieldMask;
44 import com.google.protobuf.Timestamp;
45 import java.io.IOException;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.HashMap;
49 import java.util.List;
50 import java.util.concurrent.ExecutionException;
51 import javax.annotation.Generated;
52 import org.junit.After;
53 import org.junit.AfterClass;
54 import org.junit.Assert;
55 import org.junit.Before;
56 import org.junit.BeforeClass;
57 import org.junit.Test;
58 
59 @Generated("by gapic-generator-java")
60 public class SpeechClientHttpJsonTest {
61   private static MockHttpService mockService;
62   private static SpeechClient client;
63 
64   @BeforeClass
startStaticServer()65   public static void startStaticServer() throws IOException {
66     mockService =
67         new MockHttpService(
68             HttpJsonSpeechStub.getMethodDescriptors(), SpeechSettings.getDefaultEndpoint());
69     SpeechSettings settings =
70         SpeechSettings.newHttpJsonBuilder()
71             .setTransportChannelProvider(
72                 SpeechSettings.defaultHttpJsonTransportProviderBuilder()
73                     .setHttpTransport(mockService)
74                     .build())
75             .setCredentialsProvider(NoCredentialsProvider.create())
76             .build();
77     client = SpeechClient.create(settings);
78   }
79 
80   @AfterClass
stopServer()81   public static void stopServer() {
82     client.close();
83   }
84 
85   @Before
setUp()86   public void setUp() {}
87 
88   @After
tearDown()89   public void tearDown() throws Exception {
90     mockService.reset();
91   }
92 
93   @Test
createRecognizerTest()94   public void createRecognizerTest() throws Exception {
95     Recognizer expectedResponse =
96         Recognizer.newBuilder()
97             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
98             .setUid("uid115792")
99             .setDisplayName("displayName1714148973")
100             .setModel("model104069929")
101             .addAllLanguageCodes(new ArrayList<String>())
102             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
103             .putAllAnnotations(new HashMap<String, String>())
104             .setCreateTime(Timestamp.newBuilder().build())
105             .setUpdateTime(Timestamp.newBuilder().build())
106             .setDeleteTime(Timestamp.newBuilder().build())
107             .setExpireTime(Timestamp.newBuilder().build())
108             .setEtag("etag3123477")
109             .setReconciling(true)
110             .setKmsKeyName("kmsKeyName412586233")
111             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
112             .build();
113     Operation resultOperation =
114         Operation.newBuilder()
115             .setName("createRecognizerTest")
116             .setDone(true)
117             .setResponse(Any.pack(expectedResponse))
118             .build();
119     mockService.addResponse(resultOperation);
120 
121     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
122     Recognizer recognizer = Recognizer.newBuilder().build();
123     String recognizerId = "recognizerId771963359";
124 
125     Recognizer actualResponse =
126         client.createRecognizerAsync(parent, recognizer, recognizerId).get();
127     Assert.assertEquals(expectedResponse, actualResponse);
128 
129     List<String> actualRequests = mockService.getRequestPaths();
130     Assert.assertEquals(1, actualRequests.size());
131 
132     String apiClientHeaderKey =
133         mockService
134             .getRequestHeaders()
135             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
136             .iterator()
137             .next();
138     Assert.assertTrue(
139         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
140             .matcher(apiClientHeaderKey)
141             .matches());
142   }
143 
144   @Test
createRecognizerExceptionTest()145   public void createRecognizerExceptionTest() throws Exception {
146     ApiException exception =
147         ApiExceptionFactory.createException(
148             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
149     mockService.addException(exception);
150 
151     try {
152       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
153       Recognizer recognizer = Recognizer.newBuilder().build();
154       String recognizerId = "recognizerId771963359";
155       client.createRecognizerAsync(parent, recognizer, recognizerId).get();
156       Assert.fail("No exception raised");
157     } catch (ExecutionException e) {
158     }
159   }
160 
161   @Test
createRecognizerTest2()162   public void createRecognizerTest2() throws Exception {
163     Recognizer expectedResponse =
164         Recognizer.newBuilder()
165             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
166             .setUid("uid115792")
167             .setDisplayName("displayName1714148973")
168             .setModel("model104069929")
169             .addAllLanguageCodes(new ArrayList<String>())
170             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
171             .putAllAnnotations(new HashMap<String, String>())
172             .setCreateTime(Timestamp.newBuilder().build())
173             .setUpdateTime(Timestamp.newBuilder().build())
174             .setDeleteTime(Timestamp.newBuilder().build())
175             .setExpireTime(Timestamp.newBuilder().build())
176             .setEtag("etag3123477")
177             .setReconciling(true)
178             .setKmsKeyName("kmsKeyName412586233")
179             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
180             .build();
181     Operation resultOperation =
182         Operation.newBuilder()
183             .setName("createRecognizerTest")
184             .setDone(true)
185             .setResponse(Any.pack(expectedResponse))
186             .build();
187     mockService.addResponse(resultOperation);
188 
189     String parent = "projects/project-5833/locations/location-5833";
190     Recognizer recognizer = Recognizer.newBuilder().build();
191     String recognizerId = "recognizerId771963359";
192 
193     Recognizer actualResponse =
194         client.createRecognizerAsync(parent, recognizer, recognizerId).get();
195     Assert.assertEquals(expectedResponse, actualResponse);
196 
197     List<String> actualRequests = mockService.getRequestPaths();
198     Assert.assertEquals(1, actualRequests.size());
199 
200     String apiClientHeaderKey =
201         mockService
202             .getRequestHeaders()
203             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
204             .iterator()
205             .next();
206     Assert.assertTrue(
207         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
208             .matcher(apiClientHeaderKey)
209             .matches());
210   }
211 
212   @Test
createRecognizerExceptionTest2()213   public void createRecognizerExceptionTest2() throws Exception {
214     ApiException exception =
215         ApiExceptionFactory.createException(
216             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
217     mockService.addException(exception);
218 
219     try {
220       String parent = "projects/project-5833/locations/location-5833";
221       Recognizer recognizer = Recognizer.newBuilder().build();
222       String recognizerId = "recognizerId771963359";
223       client.createRecognizerAsync(parent, recognizer, recognizerId).get();
224       Assert.fail("No exception raised");
225     } catch (ExecutionException e) {
226     }
227   }
228 
229   @Test
listRecognizersTest()230   public void listRecognizersTest() throws Exception {
231     Recognizer responsesElement = Recognizer.newBuilder().build();
232     ListRecognizersResponse expectedResponse =
233         ListRecognizersResponse.newBuilder()
234             .setNextPageToken("")
235             .addAllRecognizers(Arrays.asList(responsesElement))
236             .build();
237     mockService.addResponse(expectedResponse);
238 
239     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
240 
241     ListRecognizersPagedResponse pagedListResponse = client.listRecognizers(parent);
242 
243     List<Recognizer> resources = Lists.newArrayList(pagedListResponse.iterateAll());
244 
245     Assert.assertEquals(1, resources.size());
246     Assert.assertEquals(expectedResponse.getRecognizersList().get(0), resources.get(0));
247 
248     List<String> actualRequests = mockService.getRequestPaths();
249     Assert.assertEquals(1, actualRequests.size());
250 
251     String apiClientHeaderKey =
252         mockService
253             .getRequestHeaders()
254             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
255             .iterator()
256             .next();
257     Assert.assertTrue(
258         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
259             .matcher(apiClientHeaderKey)
260             .matches());
261   }
262 
263   @Test
listRecognizersExceptionTest()264   public void listRecognizersExceptionTest() throws Exception {
265     ApiException exception =
266         ApiExceptionFactory.createException(
267             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
268     mockService.addException(exception);
269 
270     try {
271       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
272       client.listRecognizers(parent);
273       Assert.fail("No exception raised");
274     } catch (InvalidArgumentException e) {
275       // Expected exception.
276     }
277   }
278 
279   @Test
listRecognizersTest2()280   public void listRecognizersTest2() throws Exception {
281     Recognizer responsesElement = Recognizer.newBuilder().build();
282     ListRecognizersResponse expectedResponse =
283         ListRecognizersResponse.newBuilder()
284             .setNextPageToken("")
285             .addAllRecognizers(Arrays.asList(responsesElement))
286             .build();
287     mockService.addResponse(expectedResponse);
288 
289     String parent = "projects/project-5833/locations/location-5833";
290 
291     ListRecognizersPagedResponse pagedListResponse = client.listRecognizers(parent);
292 
293     List<Recognizer> resources = Lists.newArrayList(pagedListResponse.iterateAll());
294 
295     Assert.assertEquals(1, resources.size());
296     Assert.assertEquals(expectedResponse.getRecognizersList().get(0), resources.get(0));
297 
298     List<String> actualRequests = mockService.getRequestPaths();
299     Assert.assertEquals(1, actualRequests.size());
300 
301     String apiClientHeaderKey =
302         mockService
303             .getRequestHeaders()
304             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
305             .iterator()
306             .next();
307     Assert.assertTrue(
308         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
309             .matcher(apiClientHeaderKey)
310             .matches());
311   }
312 
313   @Test
listRecognizersExceptionTest2()314   public void listRecognizersExceptionTest2() throws Exception {
315     ApiException exception =
316         ApiExceptionFactory.createException(
317             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
318     mockService.addException(exception);
319 
320     try {
321       String parent = "projects/project-5833/locations/location-5833";
322       client.listRecognizers(parent);
323       Assert.fail("No exception raised");
324     } catch (InvalidArgumentException e) {
325       // Expected exception.
326     }
327   }
328 
329   @Test
getRecognizerTest()330   public void getRecognizerTest() throws Exception {
331     Recognizer expectedResponse =
332         Recognizer.newBuilder()
333             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
334             .setUid("uid115792")
335             .setDisplayName("displayName1714148973")
336             .setModel("model104069929")
337             .addAllLanguageCodes(new ArrayList<String>())
338             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
339             .putAllAnnotations(new HashMap<String, String>())
340             .setCreateTime(Timestamp.newBuilder().build())
341             .setUpdateTime(Timestamp.newBuilder().build())
342             .setDeleteTime(Timestamp.newBuilder().build())
343             .setExpireTime(Timestamp.newBuilder().build())
344             .setEtag("etag3123477")
345             .setReconciling(true)
346             .setKmsKeyName("kmsKeyName412586233")
347             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
348             .build();
349     mockService.addResponse(expectedResponse);
350 
351     RecognizerName name = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
352 
353     Recognizer actualResponse = client.getRecognizer(name);
354     Assert.assertEquals(expectedResponse, actualResponse);
355 
356     List<String> actualRequests = mockService.getRequestPaths();
357     Assert.assertEquals(1, actualRequests.size());
358 
359     String apiClientHeaderKey =
360         mockService
361             .getRequestHeaders()
362             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
363             .iterator()
364             .next();
365     Assert.assertTrue(
366         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
367             .matcher(apiClientHeaderKey)
368             .matches());
369   }
370 
371   @Test
getRecognizerExceptionTest()372   public void getRecognizerExceptionTest() throws Exception {
373     ApiException exception =
374         ApiExceptionFactory.createException(
375             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
376     mockService.addException(exception);
377 
378     try {
379       RecognizerName name = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
380       client.getRecognizer(name);
381       Assert.fail("No exception raised");
382     } catch (InvalidArgumentException e) {
383       // Expected exception.
384     }
385   }
386 
387   @Test
getRecognizerTest2()388   public void getRecognizerTest2() throws Exception {
389     Recognizer expectedResponse =
390         Recognizer.newBuilder()
391             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
392             .setUid("uid115792")
393             .setDisplayName("displayName1714148973")
394             .setModel("model104069929")
395             .addAllLanguageCodes(new ArrayList<String>())
396             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
397             .putAllAnnotations(new HashMap<String, String>())
398             .setCreateTime(Timestamp.newBuilder().build())
399             .setUpdateTime(Timestamp.newBuilder().build())
400             .setDeleteTime(Timestamp.newBuilder().build())
401             .setExpireTime(Timestamp.newBuilder().build())
402             .setEtag("etag3123477")
403             .setReconciling(true)
404             .setKmsKeyName("kmsKeyName412586233")
405             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
406             .build();
407     mockService.addResponse(expectedResponse);
408 
409     String name = "projects/project-4309/locations/location-4309/recognizers/recognizer-4309";
410 
411     Recognizer actualResponse = client.getRecognizer(name);
412     Assert.assertEquals(expectedResponse, actualResponse);
413 
414     List<String> actualRequests = mockService.getRequestPaths();
415     Assert.assertEquals(1, actualRequests.size());
416 
417     String apiClientHeaderKey =
418         mockService
419             .getRequestHeaders()
420             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
421             .iterator()
422             .next();
423     Assert.assertTrue(
424         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
425             .matcher(apiClientHeaderKey)
426             .matches());
427   }
428 
429   @Test
getRecognizerExceptionTest2()430   public void getRecognizerExceptionTest2() throws Exception {
431     ApiException exception =
432         ApiExceptionFactory.createException(
433             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
434     mockService.addException(exception);
435 
436     try {
437       String name = "projects/project-4309/locations/location-4309/recognizers/recognizer-4309";
438       client.getRecognizer(name);
439       Assert.fail("No exception raised");
440     } catch (InvalidArgumentException e) {
441       // Expected exception.
442     }
443   }
444 
445   @Test
updateRecognizerTest()446   public void updateRecognizerTest() throws Exception {
447     Recognizer expectedResponse =
448         Recognizer.newBuilder()
449             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
450             .setUid("uid115792")
451             .setDisplayName("displayName1714148973")
452             .setModel("model104069929")
453             .addAllLanguageCodes(new ArrayList<String>())
454             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
455             .putAllAnnotations(new HashMap<String, String>())
456             .setCreateTime(Timestamp.newBuilder().build())
457             .setUpdateTime(Timestamp.newBuilder().build())
458             .setDeleteTime(Timestamp.newBuilder().build())
459             .setExpireTime(Timestamp.newBuilder().build())
460             .setEtag("etag3123477")
461             .setReconciling(true)
462             .setKmsKeyName("kmsKeyName412586233")
463             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
464             .build();
465     Operation resultOperation =
466         Operation.newBuilder()
467             .setName("updateRecognizerTest")
468             .setDone(true)
469             .setResponse(Any.pack(expectedResponse))
470             .build();
471     mockService.addResponse(resultOperation);
472 
473     Recognizer recognizer =
474         Recognizer.newBuilder()
475             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
476             .setUid("uid115792")
477             .setDisplayName("displayName1714148973")
478             .setModel("model104069929")
479             .addAllLanguageCodes(new ArrayList<String>())
480             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
481             .putAllAnnotations(new HashMap<String, String>())
482             .setCreateTime(Timestamp.newBuilder().build())
483             .setUpdateTime(Timestamp.newBuilder().build())
484             .setDeleteTime(Timestamp.newBuilder().build())
485             .setExpireTime(Timestamp.newBuilder().build())
486             .setEtag("etag3123477")
487             .setReconciling(true)
488             .setKmsKeyName("kmsKeyName412586233")
489             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
490             .build();
491     FieldMask updateMask = FieldMask.newBuilder().build();
492 
493     Recognizer actualResponse = client.updateRecognizerAsync(recognizer, updateMask).get();
494     Assert.assertEquals(expectedResponse, actualResponse);
495 
496     List<String> actualRequests = mockService.getRequestPaths();
497     Assert.assertEquals(1, actualRequests.size());
498 
499     String apiClientHeaderKey =
500         mockService
501             .getRequestHeaders()
502             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
503             .iterator()
504             .next();
505     Assert.assertTrue(
506         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
507             .matcher(apiClientHeaderKey)
508             .matches());
509   }
510 
511   @Test
updateRecognizerExceptionTest()512   public void updateRecognizerExceptionTest() throws Exception {
513     ApiException exception =
514         ApiExceptionFactory.createException(
515             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
516     mockService.addException(exception);
517 
518     try {
519       Recognizer recognizer =
520           Recognizer.newBuilder()
521               .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
522               .setUid("uid115792")
523               .setDisplayName("displayName1714148973")
524               .setModel("model104069929")
525               .addAllLanguageCodes(new ArrayList<String>())
526               .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
527               .putAllAnnotations(new HashMap<String, String>())
528               .setCreateTime(Timestamp.newBuilder().build())
529               .setUpdateTime(Timestamp.newBuilder().build())
530               .setDeleteTime(Timestamp.newBuilder().build())
531               .setExpireTime(Timestamp.newBuilder().build())
532               .setEtag("etag3123477")
533               .setReconciling(true)
534               .setKmsKeyName("kmsKeyName412586233")
535               .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
536               .build();
537       FieldMask updateMask = FieldMask.newBuilder().build();
538       client.updateRecognizerAsync(recognizer, updateMask).get();
539       Assert.fail("No exception raised");
540     } catch (ExecutionException e) {
541     }
542   }
543 
544   @Test
deleteRecognizerTest()545   public void deleteRecognizerTest() throws Exception {
546     Recognizer expectedResponse =
547         Recognizer.newBuilder()
548             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
549             .setUid("uid115792")
550             .setDisplayName("displayName1714148973")
551             .setModel("model104069929")
552             .addAllLanguageCodes(new ArrayList<String>())
553             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
554             .putAllAnnotations(new HashMap<String, String>())
555             .setCreateTime(Timestamp.newBuilder().build())
556             .setUpdateTime(Timestamp.newBuilder().build())
557             .setDeleteTime(Timestamp.newBuilder().build())
558             .setExpireTime(Timestamp.newBuilder().build())
559             .setEtag("etag3123477")
560             .setReconciling(true)
561             .setKmsKeyName("kmsKeyName412586233")
562             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
563             .build();
564     Operation resultOperation =
565         Operation.newBuilder()
566             .setName("deleteRecognizerTest")
567             .setDone(true)
568             .setResponse(Any.pack(expectedResponse))
569             .build();
570     mockService.addResponse(resultOperation);
571 
572     RecognizerName name = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
573 
574     Recognizer actualResponse = client.deleteRecognizerAsync(name).get();
575     Assert.assertEquals(expectedResponse, actualResponse);
576 
577     List<String> actualRequests = mockService.getRequestPaths();
578     Assert.assertEquals(1, actualRequests.size());
579 
580     String apiClientHeaderKey =
581         mockService
582             .getRequestHeaders()
583             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
584             .iterator()
585             .next();
586     Assert.assertTrue(
587         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
588             .matcher(apiClientHeaderKey)
589             .matches());
590   }
591 
592   @Test
deleteRecognizerExceptionTest()593   public void deleteRecognizerExceptionTest() throws Exception {
594     ApiException exception =
595         ApiExceptionFactory.createException(
596             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
597     mockService.addException(exception);
598 
599     try {
600       RecognizerName name = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
601       client.deleteRecognizerAsync(name).get();
602       Assert.fail("No exception raised");
603     } catch (ExecutionException e) {
604     }
605   }
606 
607   @Test
deleteRecognizerTest2()608   public void deleteRecognizerTest2() throws Exception {
609     Recognizer expectedResponse =
610         Recognizer.newBuilder()
611             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
612             .setUid("uid115792")
613             .setDisplayName("displayName1714148973")
614             .setModel("model104069929")
615             .addAllLanguageCodes(new ArrayList<String>())
616             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
617             .putAllAnnotations(new HashMap<String, String>())
618             .setCreateTime(Timestamp.newBuilder().build())
619             .setUpdateTime(Timestamp.newBuilder().build())
620             .setDeleteTime(Timestamp.newBuilder().build())
621             .setExpireTime(Timestamp.newBuilder().build())
622             .setEtag("etag3123477")
623             .setReconciling(true)
624             .setKmsKeyName("kmsKeyName412586233")
625             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
626             .build();
627     Operation resultOperation =
628         Operation.newBuilder()
629             .setName("deleteRecognizerTest")
630             .setDone(true)
631             .setResponse(Any.pack(expectedResponse))
632             .build();
633     mockService.addResponse(resultOperation);
634 
635     String name = "projects/project-4309/locations/location-4309/recognizers/recognizer-4309";
636 
637     Recognizer actualResponse = client.deleteRecognizerAsync(name).get();
638     Assert.assertEquals(expectedResponse, actualResponse);
639 
640     List<String> actualRequests = mockService.getRequestPaths();
641     Assert.assertEquals(1, actualRequests.size());
642 
643     String apiClientHeaderKey =
644         mockService
645             .getRequestHeaders()
646             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
647             .iterator()
648             .next();
649     Assert.assertTrue(
650         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
651             .matcher(apiClientHeaderKey)
652             .matches());
653   }
654 
655   @Test
deleteRecognizerExceptionTest2()656   public void deleteRecognizerExceptionTest2() throws Exception {
657     ApiException exception =
658         ApiExceptionFactory.createException(
659             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
660     mockService.addException(exception);
661 
662     try {
663       String name = "projects/project-4309/locations/location-4309/recognizers/recognizer-4309";
664       client.deleteRecognizerAsync(name).get();
665       Assert.fail("No exception raised");
666     } catch (ExecutionException e) {
667     }
668   }
669 
670   @Test
undeleteRecognizerTest()671   public void undeleteRecognizerTest() throws Exception {
672     Recognizer expectedResponse =
673         Recognizer.newBuilder()
674             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
675             .setUid("uid115792")
676             .setDisplayName("displayName1714148973")
677             .setModel("model104069929")
678             .addAllLanguageCodes(new ArrayList<String>())
679             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
680             .putAllAnnotations(new HashMap<String, String>())
681             .setCreateTime(Timestamp.newBuilder().build())
682             .setUpdateTime(Timestamp.newBuilder().build())
683             .setDeleteTime(Timestamp.newBuilder().build())
684             .setExpireTime(Timestamp.newBuilder().build())
685             .setEtag("etag3123477")
686             .setReconciling(true)
687             .setKmsKeyName("kmsKeyName412586233")
688             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
689             .build();
690     Operation resultOperation =
691         Operation.newBuilder()
692             .setName("undeleteRecognizerTest")
693             .setDone(true)
694             .setResponse(Any.pack(expectedResponse))
695             .build();
696     mockService.addResponse(resultOperation);
697 
698     RecognizerName name = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
699 
700     Recognizer actualResponse = client.undeleteRecognizerAsync(name).get();
701     Assert.assertEquals(expectedResponse, actualResponse);
702 
703     List<String> actualRequests = mockService.getRequestPaths();
704     Assert.assertEquals(1, actualRequests.size());
705 
706     String apiClientHeaderKey =
707         mockService
708             .getRequestHeaders()
709             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
710             .iterator()
711             .next();
712     Assert.assertTrue(
713         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
714             .matcher(apiClientHeaderKey)
715             .matches());
716   }
717 
718   @Test
undeleteRecognizerExceptionTest()719   public void undeleteRecognizerExceptionTest() throws Exception {
720     ApiException exception =
721         ApiExceptionFactory.createException(
722             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
723     mockService.addException(exception);
724 
725     try {
726       RecognizerName name = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
727       client.undeleteRecognizerAsync(name).get();
728       Assert.fail("No exception raised");
729     } catch (ExecutionException e) {
730     }
731   }
732 
733   @Test
undeleteRecognizerTest2()734   public void undeleteRecognizerTest2() throws Exception {
735     Recognizer expectedResponse =
736         Recognizer.newBuilder()
737             .setName(RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]").toString())
738             .setUid("uid115792")
739             .setDisplayName("displayName1714148973")
740             .setModel("model104069929")
741             .addAllLanguageCodes(new ArrayList<String>())
742             .setDefaultRecognitionConfig(RecognitionConfig.newBuilder().build())
743             .putAllAnnotations(new HashMap<String, String>())
744             .setCreateTime(Timestamp.newBuilder().build())
745             .setUpdateTime(Timestamp.newBuilder().build())
746             .setDeleteTime(Timestamp.newBuilder().build())
747             .setExpireTime(Timestamp.newBuilder().build())
748             .setEtag("etag3123477")
749             .setReconciling(true)
750             .setKmsKeyName("kmsKeyName412586233")
751             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
752             .build();
753     Operation resultOperation =
754         Operation.newBuilder()
755             .setName("undeleteRecognizerTest")
756             .setDone(true)
757             .setResponse(Any.pack(expectedResponse))
758             .build();
759     mockService.addResponse(resultOperation);
760 
761     String name = "projects/project-4309/locations/location-4309/recognizers/recognizer-4309";
762 
763     Recognizer actualResponse = client.undeleteRecognizerAsync(name).get();
764     Assert.assertEquals(expectedResponse, actualResponse);
765 
766     List<String> actualRequests = mockService.getRequestPaths();
767     Assert.assertEquals(1, actualRequests.size());
768 
769     String apiClientHeaderKey =
770         mockService
771             .getRequestHeaders()
772             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
773             .iterator()
774             .next();
775     Assert.assertTrue(
776         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
777             .matcher(apiClientHeaderKey)
778             .matches());
779   }
780 
781   @Test
undeleteRecognizerExceptionTest2()782   public void undeleteRecognizerExceptionTest2() throws Exception {
783     ApiException exception =
784         ApiExceptionFactory.createException(
785             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
786     mockService.addException(exception);
787 
788     try {
789       String name = "projects/project-4309/locations/location-4309/recognizers/recognizer-4309";
790       client.undeleteRecognizerAsync(name).get();
791       Assert.fail("No exception raised");
792     } catch (ExecutionException e) {
793     }
794   }
795 
796   @Test
recognizeTest()797   public void recognizeTest() throws Exception {
798     RecognizeResponse expectedResponse =
799         RecognizeResponse.newBuilder()
800             .addAllResults(new ArrayList<SpeechRecognitionResult>())
801             .setMetadata(RecognitionResponseMetadata.newBuilder().build())
802             .build();
803     mockService.addResponse(expectedResponse);
804 
805     RecognizerName recognizer = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
806     RecognitionConfig config = RecognitionConfig.newBuilder().build();
807     FieldMask configMask = FieldMask.newBuilder().build();
808     ByteString content = ByteString.EMPTY;
809 
810     RecognizeResponse actualResponse = client.recognize(recognizer, config, configMask, content);
811     Assert.assertEquals(expectedResponse, actualResponse);
812 
813     List<String> actualRequests = mockService.getRequestPaths();
814     Assert.assertEquals(1, actualRequests.size());
815 
816     String apiClientHeaderKey =
817         mockService
818             .getRequestHeaders()
819             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
820             .iterator()
821             .next();
822     Assert.assertTrue(
823         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
824             .matcher(apiClientHeaderKey)
825             .matches());
826   }
827 
828   @Test
recognizeExceptionTest()829   public void recognizeExceptionTest() throws Exception {
830     ApiException exception =
831         ApiExceptionFactory.createException(
832             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
833     mockService.addException(exception);
834 
835     try {
836       RecognizerName recognizer = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
837       RecognitionConfig config = RecognitionConfig.newBuilder().build();
838       FieldMask configMask = FieldMask.newBuilder().build();
839       ByteString content = ByteString.EMPTY;
840       client.recognize(recognizer, config, configMask, content);
841       Assert.fail("No exception raised");
842     } catch (InvalidArgumentException e) {
843       // Expected exception.
844     }
845   }
846 
847   @Test
recognizeTest2()848   public void recognizeTest2() throws Exception {
849     RecognizeResponse expectedResponse =
850         RecognizeResponse.newBuilder()
851             .addAllResults(new ArrayList<SpeechRecognitionResult>())
852             .setMetadata(RecognitionResponseMetadata.newBuilder().build())
853             .build();
854     mockService.addResponse(expectedResponse);
855 
856     RecognizerName recognizer = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
857     RecognitionConfig config = RecognitionConfig.newBuilder().build();
858     FieldMask configMask = FieldMask.newBuilder().build();
859     String uri = "uri116076";
860 
861     RecognizeResponse actualResponse = client.recognize(recognizer, config, configMask, uri);
862     Assert.assertEquals(expectedResponse, actualResponse);
863 
864     List<String> actualRequests = mockService.getRequestPaths();
865     Assert.assertEquals(1, actualRequests.size());
866 
867     String apiClientHeaderKey =
868         mockService
869             .getRequestHeaders()
870             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
871             .iterator()
872             .next();
873     Assert.assertTrue(
874         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
875             .matcher(apiClientHeaderKey)
876             .matches());
877   }
878 
879   @Test
recognizeExceptionTest2()880   public void recognizeExceptionTest2() throws Exception {
881     ApiException exception =
882         ApiExceptionFactory.createException(
883             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
884     mockService.addException(exception);
885 
886     try {
887       RecognizerName recognizer = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
888       RecognitionConfig config = RecognitionConfig.newBuilder().build();
889       FieldMask configMask = FieldMask.newBuilder().build();
890       String uri = "uri116076";
891       client.recognize(recognizer, config, configMask, uri);
892       Assert.fail("No exception raised");
893     } catch (InvalidArgumentException e) {
894       // Expected exception.
895     }
896   }
897 
898   @Test
recognizeTest3()899   public void recognizeTest3() throws Exception {
900     RecognizeResponse expectedResponse =
901         RecognizeResponse.newBuilder()
902             .addAllResults(new ArrayList<SpeechRecognitionResult>())
903             .setMetadata(RecognitionResponseMetadata.newBuilder().build())
904             .build();
905     mockService.addResponse(expectedResponse);
906 
907     String recognizer = "projects/project-2882/locations/location-2882/recognizers/recognizer-2882";
908     RecognitionConfig config = RecognitionConfig.newBuilder().build();
909     FieldMask configMask = FieldMask.newBuilder().build();
910     ByteString content = ByteString.EMPTY;
911 
912     RecognizeResponse actualResponse = client.recognize(recognizer, config, configMask, content);
913     Assert.assertEquals(expectedResponse, actualResponse);
914 
915     List<String> actualRequests = mockService.getRequestPaths();
916     Assert.assertEquals(1, actualRequests.size());
917 
918     String apiClientHeaderKey =
919         mockService
920             .getRequestHeaders()
921             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
922             .iterator()
923             .next();
924     Assert.assertTrue(
925         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
926             .matcher(apiClientHeaderKey)
927             .matches());
928   }
929 
930   @Test
recognizeExceptionTest3()931   public void recognizeExceptionTest3() throws Exception {
932     ApiException exception =
933         ApiExceptionFactory.createException(
934             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
935     mockService.addException(exception);
936 
937     try {
938       String recognizer =
939           "projects/project-2882/locations/location-2882/recognizers/recognizer-2882";
940       RecognitionConfig config = RecognitionConfig.newBuilder().build();
941       FieldMask configMask = FieldMask.newBuilder().build();
942       ByteString content = ByteString.EMPTY;
943       client.recognize(recognizer, config, configMask, content);
944       Assert.fail("No exception raised");
945     } catch (InvalidArgumentException e) {
946       // Expected exception.
947     }
948   }
949 
950   @Test
recognizeTest4()951   public void recognizeTest4() throws Exception {
952     RecognizeResponse expectedResponse =
953         RecognizeResponse.newBuilder()
954             .addAllResults(new ArrayList<SpeechRecognitionResult>())
955             .setMetadata(RecognitionResponseMetadata.newBuilder().build())
956             .build();
957     mockService.addResponse(expectedResponse);
958 
959     String recognizer = "projects/project-2882/locations/location-2882/recognizers/recognizer-2882";
960     RecognitionConfig config = RecognitionConfig.newBuilder().build();
961     FieldMask configMask = FieldMask.newBuilder().build();
962     String uri = "uri116076";
963 
964     RecognizeResponse actualResponse = client.recognize(recognizer, config, configMask, uri);
965     Assert.assertEquals(expectedResponse, actualResponse);
966 
967     List<String> actualRequests = mockService.getRequestPaths();
968     Assert.assertEquals(1, actualRequests.size());
969 
970     String apiClientHeaderKey =
971         mockService
972             .getRequestHeaders()
973             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
974             .iterator()
975             .next();
976     Assert.assertTrue(
977         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
978             .matcher(apiClientHeaderKey)
979             .matches());
980   }
981 
982   @Test
recognizeExceptionTest4()983   public void recognizeExceptionTest4() throws Exception {
984     ApiException exception =
985         ApiExceptionFactory.createException(
986             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
987     mockService.addException(exception);
988 
989     try {
990       String recognizer =
991           "projects/project-2882/locations/location-2882/recognizers/recognizer-2882";
992       RecognitionConfig config = RecognitionConfig.newBuilder().build();
993       FieldMask configMask = FieldMask.newBuilder().build();
994       String uri = "uri116076";
995       client.recognize(recognizer, config, configMask, uri);
996       Assert.fail("No exception raised");
997     } catch (InvalidArgumentException e) {
998       // Expected exception.
999     }
1000   }
1001 
1002   @Test
streamingRecognizeUnsupportedMethodTest()1003   public void streamingRecognizeUnsupportedMethodTest() throws Exception {
1004     // The streamingRecognize() method is not supported in REST transport.
1005     // This empty test is generated for technical reasons.
1006   }
1007 
1008   @Test
batchRecognizeTest()1009   public void batchRecognizeTest() throws Exception {
1010     BatchRecognizeResponse expectedResponse =
1011         BatchRecognizeResponse.newBuilder()
1012             .putAllResults(new HashMap<String, BatchRecognizeFileResult>())
1013             .setTotalBilledDuration(Duration.newBuilder().build())
1014             .build();
1015     Operation resultOperation =
1016         Operation.newBuilder()
1017             .setName("batchRecognizeTest")
1018             .setDone(true)
1019             .setResponse(Any.pack(expectedResponse))
1020             .build();
1021     mockService.addResponse(resultOperation);
1022 
1023     RecognizerName recognizer = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
1024     RecognitionConfig config = RecognitionConfig.newBuilder().build();
1025     FieldMask configMask = FieldMask.newBuilder().build();
1026     List<BatchRecognizeFileMetadata> files = new ArrayList<>();
1027 
1028     BatchRecognizeResponse actualResponse =
1029         client.batchRecognizeAsync(recognizer, config, configMask, files).get();
1030     Assert.assertEquals(expectedResponse, actualResponse);
1031 
1032     List<String> actualRequests = mockService.getRequestPaths();
1033     Assert.assertEquals(1, actualRequests.size());
1034 
1035     String apiClientHeaderKey =
1036         mockService
1037             .getRequestHeaders()
1038             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1039             .iterator()
1040             .next();
1041     Assert.assertTrue(
1042         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1043             .matcher(apiClientHeaderKey)
1044             .matches());
1045   }
1046 
1047   @Test
batchRecognizeExceptionTest()1048   public void batchRecognizeExceptionTest() throws Exception {
1049     ApiException exception =
1050         ApiExceptionFactory.createException(
1051             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1052     mockService.addException(exception);
1053 
1054     try {
1055       RecognizerName recognizer = RecognizerName.of("[PROJECT]", "[LOCATION]", "[RECOGNIZER]");
1056       RecognitionConfig config = RecognitionConfig.newBuilder().build();
1057       FieldMask configMask = FieldMask.newBuilder().build();
1058       List<BatchRecognizeFileMetadata> files = new ArrayList<>();
1059       client.batchRecognizeAsync(recognizer, config, configMask, files).get();
1060       Assert.fail("No exception raised");
1061     } catch (ExecutionException e) {
1062     }
1063   }
1064 
1065   @Test
batchRecognizeTest2()1066   public void batchRecognizeTest2() throws Exception {
1067     BatchRecognizeResponse expectedResponse =
1068         BatchRecognizeResponse.newBuilder()
1069             .putAllResults(new HashMap<String, BatchRecognizeFileResult>())
1070             .setTotalBilledDuration(Duration.newBuilder().build())
1071             .build();
1072     Operation resultOperation =
1073         Operation.newBuilder()
1074             .setName("batchRecognizeTest")
1075             .setDone(true)
1076             .setResponse(Any.pack(expectedResponse))
1077             .build();
1078     mockService.addResponse(resultOperation);
1079 
1080     String recognizer = "projects/project-2882/locations/location-2882/recognizers/recognizer-2882";
1081     RecognitionConfig config = RecognitionConfig.newBuilder().build();
1082     FieldMask configMask = FieldMask.newBuilder().build();
1083     List<BatchRecognizeFileMetadata> files = new ArrayList<>();
1084 
1085     BatchRecognizeResponse actualResponse =
1086         client.batchRecognizeAsync(recognizer, config, configMask, files).get();
1087     Assert.assertEquals(expectedResponse, actualResponse);
1088 
1089     List<String> actualRequests = mockService.getRequestPaths();
1090     Assert.assertEquals(1, actualRequests.size());
1091 
1092     String apiClientHeaderKey =
1093         mockService
1094             .getRequestHeaders()
1095             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1096             .iterator()
1097             .next();
1098     Assert.assertTrue(
1099         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1100             .matcher(apiClientHeaderKey)
1101             .matches());
1102   }
1103 
1104   @Test
batchRecognizeExceptionTest2()1105   public void batchRecognizeExceptionTest2() throws Exception {
1106     ApiException exception =
1107         ApiExceptionFactory.createException(
1108             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1109     mockService.addException(exception);
1110 
1111     try {
1112       String recognizer =
1113           "projects/project-2882/locations/location-2882/recognizers/recognizer-2882";
1114       RecognitionConfig config = RecognitionConfig.newBuilder().build();
1115       FieldMask configMask = FieldMask.newBuilder().build();
1116       List<BatchRecognizeFileMetadata> files = new ArrayList<>();
1117       client.batchRecognizeAsync(recognizer, config, configMask, files).get();
1118       Assert.fail("No exception raised");
1119     } catch (ExecutionException e) {
1120     }
1121   }
1122 
1123   @Test
getConfigTest()1124   public void getConfigTest() throws Exception {
1125     Config expectedResponse =
1126         Config.newBuilder()
1127             .setName(ConfigName.of("[PROJECT]", "[LOCATION]").toString())
1128             .setKmsKeyName("kmsKeyName412586233")
1129             .setUpdateTime(Timestamp.newBuilder().build())
1130             .build();
1131     mockService.addResponse(expectedResponse);
1132 
1133     ConfigName name = ConfigName.of("[PROJECT]", "[LOCATION]");
1134 
1135     Config actualResponse = client.getConfig(name);
1136     Assert.assertEquals(expectedResponse, actualResponse);
1137 
1138     List<String> actualRequests = mockService.getRequestPaths();
1139     Assert.assertEquals(1, actualRequests.size());
1140 
1141     String apiClientHeaderKey =
1142         mockService
1143             .getRequestHeaders()
1144             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1145             .iterator()
1146             .next();
1147     Assert.assertTrue(
1148         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1149             .matcher(apiClientHeaderKey)
1150             .matches());
1151   }
1152 
1153   @Test
getConfigExceptionTest()1154   public void getConfigExceptionTest() throws Exception {
1155     ApiException exception =
1156         ApiExceptionFactory.createException(
1157             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1158     mockService.addException(exception);
1159 
1160     try {
1161       ConfigName name = ConfigName.of("[PROJECT]", "[LOCATION]");
1162       client.getConfig(name);
1163       Assert.fail("No exception raised");
1164     } catch (InvalidArgumentException e) {
1165       // Expected exception.
1166     }
1167   }
1168 
1169   @Test
getConfigTest2()1170   public void getConfigTest2() throws Exception {
1171     Config expectedResponse =
1172         Config.newBuilder()
1173             .setName(ConfigName.of("[PROJECT]", "[LOCATION]").toString())
1174             .setKmsKeyName("kmsKeyName412586233")
1175             .setUpdateTime(Timestamp.newBuilder().build())
1176             .build();
1177     mockService.addResponse(expectedResponse);
1178 
1179     String name = "projects/project-505/locations/location-505/config";
1180 
1181     Config actualResponse = client.getConfig(name);
1182     Assert.assertEquals(expectedResponse, actualResponse);
1183 
1184     List<String> actualRequests = mockService.getRequestPaths();
1185     Assert.assertEquals(1, actualRequests.size());
1186 
1187     String apiClientHeaderKey =
1188         mockService
1189             .getRequestHeaders()
1190             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1191             .iterator()
1192             .next();
1193     Assert.assertTrue(
1194         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1195             .matcher(apiClientHeaderKey)
1196             .matches());
1197   }
1198 
1199   @Test
getConfigExceptionTest2()1200   public void getConfigExceptionTest2() throws Exception {
1201     ApiException exception =
1202         ApiExceptionFactory.createException(
1203             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1204     mockService.addException(exception);
1205 
1206     try {
1207       String name = "projects/project-505/locations/location-505/config";
1208       client.getConfig(name);
1209       Assert.fail("No exception raised");
1210     } catch (InvalidArgumentException e) {
1211       // Expected exception.
1212     }
1213   }
1214 
1215   @Test
updateConfigTest()1216   public void updateConfigTest() throws Exception {
1217     Config expectedResponse =
1218         Config.newBuilder()
1219             .setName(ConfigName.of("[PROJECT]", "[LOCATION]").toString())
1220             .setKmsKeyName("kmsKeyName412586233")
1221             .setUpdateTime(Timestamp.newBuilder().build())
1222             .build();
1223     mockService.addResponse(expectedResponse);
1224 
1225     Config config =
1226         Config.newBuilder()
1227             .setName(ConfigName.of("[PROJECT]", "[LOCATION]").toString())
1228             .setKmsKeyName("kmsKeyName412586233")
1229             .setUpdateTime(Timestamp.newBuilder().build())
1230             .build();
1231     FieldMask updateMask = FieldMask.newBuilder().build();
1232 
1233     Config actualResponse = client.updateConfig(config, updateMask);
1234     Assert.assertEquals(expectedResponse, actualResponse);
1235 
1236     List<String> actualRequests = mockService.getRequestPaths();
1237     Assert.assertEquals(1, actualRequests.size());
1238 
1239     String apiClientHeaderKey =
1240         mockService
1241             .getRequestHeaders()
1242             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1243             .iterator()
1244             .next();
1245     Assert.assertTrue(
1246         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1247             .matcher(apiClientHeaderKey)
1248             .matches());
1249   }
1250 
1251   @Test
updateConfigExceptionTest()1252   public void updateConfigExceptionTest() throws Exception {
1253     ApiException exception =
1254         ApiExceptionFactory.createException(
1255             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1256     mockService.addException(exception);
1257 
1258     try {
1259       Config config =
1260           Config.newBuilder()
1261               .setName(ConfigName.of("[PROJECT]", "[LOCATION]").toString())
1262               .setKmsKeyName("kmsKeyName412586233")
1263               .setUpdateTime(Timestamp.newBuilder().build())
1264               .build();
1265       FieldMask updateMask = FieldMask.newBuilder().build();
1266       client.updateConfig(config, updateMask);
1267       Assert.fail("No exception raised");
1268     } catch (InvalidArgumentException e) {
1269       // Expected exception.
1270     }
1271   }
1272 
1273   @Test
createCustomClassTest()1274   public void createCustomClassTest() throws Exception {
1275     CustomClass expectedResponse =
1276         CustomClass.newBuilder()
1277             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1278             .setUid("uid115792")
1279             .setDisplayName("displayName1714148973")
1280             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1281             .setCreateTime(Timestamp.newBuilder().build())
1282             .setUpdateTime(Timestamp.newBuilder().build())
1283             .setDeleteTime(Timestamp.newBuilder().build())
1284             .setExpireTime(Timestamp.newBuilder().build())
1285             .putAllAnnotations(new HashMap<String, String>())
1286             .setEtag("etag3123477")
1287             .setReconciling(true)
1288             .setKmsKeyName("kmsKeyName412586233")
1289             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1290             .build();
1291     Operation resultOperation =
1292         Operation.newBuilder()
1293             .setName("createCustomClassTest")
1294             .setDone(true)
1295             .setResponse(Any.pack(expectedResponse))
1296             .build();
1297     mockService.addResponse(resultOperation);
1298 
1299     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1300     CustomClass customClass = CustomClass.newBuilder().build();
1301     String customClassId = "customClassId1871032322";
1302 
1303     CustomClass actualResponse =
1304         client.createCustomClassAsync(parent, customClass, customClassId).get();
1305     Assert.assertEquals(expectedResponse, actualResponse);
1306 
1307     List<String> actualRequests = mockService.getRequestPaths();
1308     Assert.assertEquals(1, actualRequests.size());
1309 
1310     String apiClientHeaderKey =
1311         mockService
1312             .getRequestHeaders()
1313             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1314             .iterator()
1315             .next();
1316     Assert.assertTrue(
1317         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1318             .matcher(apiClientHeaderKey)
1319             .matches());
1320   }
1321 
1322   @Test
createCustomClassExceptionTest()1323   public void createCustomClassExceptionTest() throws Exception {
1324     ApiException exception =
1325         ApiExceptionFactory.createException(
1326             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1327     mockService.addException(exception);
1328 
1329     try {
1330       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1331       CustomClass customClass = CustomClass.newBuilder().build();
1332       String customClassId = "customClassId1871032322";
1333       client.createCustomClassAsync(parent, customClass, customClassId).get();
1334       Assert.fail("No exception raised");
1335     } catch (ExecutionException e) {
1336     }
1337   }
1338 
1339   @Test
createCustomClassTest2()1340   public void createCustomClassTest2() throws Exception {
1341     CustomClass expectedResponse =
1342         CustomClass.newBuilder()
1343             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1344             .setUid("uid115792")
1345             .setDisplayName("displayName1714148973")
1346             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1347             .setCreateTime(Timestamp.newBuilder().build())
1348             .setUpdateTime(Timestamp.newBuilder().build())
1349             .setDeleteTime(Timestamp.newBuilder().build())
1350             .setExpireTime(Timestamp.newBuilder().build())
1351             .putAllAnnotations(new HashMap<String, String>())
1352             .setEtag("etag3123477")
1353             .setReconciling(true)
1354             .setKmsKeyName("kmsKeyName412586233")
1355             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1356             .build();
1357     Operation resultOperation =
1358         Operation.newBuilder()
1359             .setName("createCustomClassTest")
1360             .setDone(true)
1361             .setResponse(Any.pack(expectedResponse))
1362             .build();
1363     mockService.addResponse(resultOperation);
1364 
1365     String parent = "projects/project-5833/locations/location-5833";
1366     CustomClass customClass = CustomClass.newBuilder().build();
1367     String customClassId = "customClassId1871032322";
1368 
1369     CustomClass actualResponse =
1370         client.createCustomClassAsync(parent, customClass, customClassId).get();
1371     Assert.assertEquals(expectedResponse, actualResponse);
1372 
1373     List<String> actualRequests = mockService.getRequestPaths();
1374     Assert.assertEquals(1, actualRequests.size());
1375 
1376     String apiClientHeaderKey =
1377         mockService
1378             .getRequestHeaders()
1379             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1380             .iterator()
1381             .next();
1382     Assert.assertTrue(
1383         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1384             .matcher(apiClientHeaderKey)
1385             .matches());
1386   }
1387 
1388   @Test
createCustomClassExceptionTest2()1389   public void createCustomClassExceptionTest2() throws Exception {
1390     ApiException exception =
1391         ApiExceptionFactory.createException(
1392             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1393     mockService.addException(exception);
1394 
1395     try {
1396       String parent = "projects/project-5833/locations/location-5833";
1397       CustomClass customClass = CustomClass.newBuilder().build();
1398       String customClassId = "customClassId1871032322";
1399       client.createCustomClassAsync(parent, customClass, customClassId).get();
1400       Assert.fail("No exception raised");
1401     } catch (ExecutionException e) {
1402     }
1403   }
1404 
1405   @Test
listCustomClassesTest()1406   public void listCustomClassesTest() throws Exception {
1407     CustomClass responsesElement = CustomClass.newBuilder().build();
1408     ListCustomClassesResponse expectedResponse =
1409         ListCustomClassesResponse.newBuilder()
1410             .setNextPageToken("")
1411             .addAllCustomClasses(Arrays.asList(responsesElement))
1412             .build();
1413     mockService.addResponse(expectedResponse);
1414 
1415     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1416 
1417     ListCustomClassesPagedResponse pagedListResponse = client.listCustomClasses(parent);
1418 
1419     List<CustomClass> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1420 
1421     Assert.assertEquals(1, resources.size());
1422     Assert.assertEquals(expectedResponse.getCustomClassesList().get(0), resources.get(0));
1423 
1424     List<String> actualRequests = mockService.getRequestPaths();
1425     Assert.assertEquals(1, actualRequests.size());
1426 
1427     String apiClientHeaderKey =
1428         mockService
1429             .getRequestHeaders()
1430             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1431             .iterator()
1432             .next();
1433     Assert.assertTrue(
1434         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1435             .matcher(apiClientHeaderKey)
1436             .matches());
1437   }
1438 
1439   @Test
listCustomClassesExceptionTest()1440   public void listCustomClassesExceptionTest() throws Exception {
1441     ApiException exception =
1442         ApiExceptionFactory.createException(
1443             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1444     mockService.addException(exception);
1445 
1446     try {
1447       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1448       client.listCustomClasses(parent);
1449       Assert.fail("No exception raised");
1450     } catch (InvalidArgumentException e) {
1451       // Expected exception.
1452     }
1453   }
1454 
1455   @Test
listCustomClassesTest2()1456   public void listCustomClassesTest2() throws Exception {
1457     CustomClass responsesElement = CustomClass.newBuilder().build();
1458     ListCustomClassesResponse expectedResponse =
1459         ListCustomClassesResponse.newBuilder()
1460             .setNextPageToken("")
1461             .addAllCustomClasses(Arrays.asList(responsesElement))
1462             .build();
1463     mockService.addResponse(expectedResponse);
1464 
1465     String parent = "projects/project-5833/locations/location-5833";
1466 
1467     ListCustomClassesPagedResponse pagedListResponse = client.listCustomClasses(parent);
1468 
1469     List<CustomClass> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1470 
1471     Assert.assertEquals(1, resources.size());
1472     Assert.assertEquals(expectedResponse.getCustomClassesList().get(0), resources.get(0));
1473 
1474     List<String> actualRequests = mockService.getRequestPaths();
1475     Assert.assertEquals(1, actualRequests.size());
1476 
1477     String apiClientHeaderKey =
1478         mockService
1479             .getRequestHeaders()
1480             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1481             .iterator()
1482             .next();
1483     Assert.assertTrue(
1484         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1485             .matcher(apiClientHeaderKey)
1486             .matches());
1487   }
1488 
1489   @Test
listCustomClassesExceptionTest2()1490   public void listCustomClassesExceptionTest2() throws Exception {
1491     ApiException exception =
1492         ApiExceptionFactory.createException(
1493             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1494     mockService.addException(exception);
1495 
1496     try {
1497       String parent = "projects/project-5833/locations/location-5833";
1498       client.listCustomClasses(parent);
1499       Assert.fail("No exception raised");
1500     } catch (InvalidArgumentException e) {
1501       // Expected exception.
1502     }
1503   }
1504 
1505   @Test
getCustomClassTest()1506   public void getCustomClassTest() throws Exception {
1507     CustomClass expectedResponse =
1508         CustomClass.newBuilder()
1509             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1510             .setUid("uid115792")
1511             .setDisplayName("displayName1714148973")
1512             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1513             .setCreateTime(Timestamp.newBuilder().build())
1514             .setUpdateTime(Timestamp.newBuilder().build())
1515             .setDeleteTime(Timestamp.newBuilder().build())
1516             .setExpireTime(Timestamp.newBuilder().build())
1517             .putAllAnnotations(new HashMap<String, String>())
1518             .setEtag("etag3123477")
1519             .setReconciling(true)
1520             .setKmsKeyName("kmsKeyName412586233")
1521             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1522             .build();
1523     mockService.addResponse(expectedResponse);
1524 
1525     CustomClassName name = CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]");
1526 
1527     CustomClass actualResponse = client.getCustomClass(name);
1528     Assert.assertEquals(expectedResponse, actualResponse);
1529 
1530     List<String> actualRequests = mockService.getRequestPaths();
1531     Assert.assertEquals(1, actualRequests.size());
1532 
1533     String apiClientHeaderKey =
1534         mockService
1535             .getRequestHeaders()
1536             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1537             .iterator()
1538             .next();
1539     Assert.assertTrue(
1540         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1541             .matcher(apiClientHeaderKey)
1542             .matches());
1543   }
1544 
1545   @Test
getCustomClassExceptionTest()1546   public void getCustomClassExceptionTest() throws Exception {
1547     ApiException exception =
1548         ApiExceptionFactory.createException(
1549             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1550     mockService.addException(exception);
1551 
1552     try {
1553       CustomClassName name = CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]");
1554       client.getCustomClass(name);
1555       Assert.fail("No exception raised");
1556     } catch (InvalidArgumentException e) {
1557       // Expected exception.
1558     }
1559   }
1560 
1561   @Test
getCustomClassTest2()1562   public void getCustomClassTest2() throws Exception {
1563     CustomClass expectedResponse =
1564         CustomClass.newBuilder()
1565             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1566             .setUid("uid115792")
1567             .setDisplayName("displayName1714148973")
1568             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1569             .setCreateTime(Timestamp.newBuilder().build())
1570             .setUpdateTime(Timestamp.newBuilder().build())
1571             .setDeleteTime(Timestamp.newBuilder().build())
1572             .setExpireTime(Timestamp.newBuilder().build())
1573             .putAllAnnotations(new HashMap<String, String>())
1574             .setEtag("etag3123477")
1575             .setReconciling(true)
1576             .setKmsKeyName("kmsKeyName412586233")
1577             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1578             .build();
1579     mockService.addResponse(expectedResponse);
1580 
1581     String name = "projects/project-4379/locations/location-4379/customClasses/customClasse-4379";
1582 
1583     CustomClass actualResponse = client.getCustomClass(name);
1584     Assert.assertEquals(expectedResponse, actualResponse);
1585 
1586     List<String> actualRequests = mockService.getRequestPaths();
1587     Assert.assertEquals(1, actualRequests.size());
1588 
1589     String apiClientHeaderKey =
1590         mockService
1591             .getRequestHeaders()
1592             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1593             .iterator()
1594             .next();
1595     Assert.assertTrue(
1596         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1597             .matcher(apiClientHeaderKey)
1598             .matches());
1599   }
1600 
1601   @Test
getCustomClassExceptionTest2()1602   public void getCustomClassExceptionTest2() throws Exception {
1603     ApiException exception =
1604         ApiExceptionFactory.createException(
1605             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1606     mockService.addException(exception);
1607 
1608     try {
1609       String name = "projects/project-4379/locations/location-4379/customClasses/customClasse-4379";
1610       client.getCustomClass(name);
1611       Assert.fail("No exception raised");
1612     } catch (InvalidArgumentException e) {
1613       // Expected exception.
1614     }
1615   }
1616 
1617   @Test
updateCustomClassTest()1618   public void updateCustomClassTest() throws Exception {
1619     CustomClass expectedResponse =
1620         CustomClass.newBuilder()
1621             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1622             .setUid("uid115792")
1623             .setDisplayName("displayName1714148973")
1624             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1625             .setCreateTime(Timestamp.newBuilder().build())
1626             .setUpdateTime(Timestamp.newBuilder().build())
1627             .setDeleteTime(Timestamp.newBuilder().build())
1628             .setExpireTime(Timestamp.newBuilder().build())
1629             .putAllAnnotations(new HashMap<String, String>())
1630             .setEtag("etag3123477")
1631             .setReconciling(true)
1632             .setKmsKeyName("kmsKeyName412586233")
1633             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1634             .build();
1635     Operation resultOperation =
1636         Operation.newBuilder()
1637             .setName("updateCustomClassTest")
1638             .setDone(true)
1639             .setResponse(Any.pack(expectedResponse))
1640             .build();
1641     mockService.addResponse(resultOperation);
1642 
1643     CustomClass customClass =
1644         CustomClass.newBuilder()
1645             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1646             .setUid("uid115792")
1647             .setDisplayName("displayName1714148973")
1648             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1649             .setCreateTime(Timestamp.newBuilder().build())
1650             .setUpdateTime(Timestamp.newBuilder().build())
1651             .setDeleteTime(Timestamp.newBuilder().build())
1652             .setExpireTime(Timestamp.newBuilder().build())
1653             .putAllAnnotations(new HashMap<String, String>())
1654             .setEtag("etag3123477")
1655             .setReconciling(true)
1656             .setKmsKeyName("kmsKeyName412586233")
1657             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1658             .build();
1659     FieldMask updateMask = FieldMask.newBuilder().build();
1660 
1661     CustomClass actualResponse = client.updateCustomClassAsync(customClass, updateMask).get();
1662     Assert.assertEquals(expectedResponse, actualResponse);
1663 
1664     List<String> actualRequests = mockService.getRequestPaths();
1665     Assert.assertEquals(1, actualRequests.size());
1666 
1667     String apiClientHeaderKey =
1668         mockService
1669             .getRequestHeaders()
1670             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1671             .iterator()
1672             .next();
1673     Assert.assertTrue(
1674         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1675             .matcher(apiClientHeaderKey)
1676             .matches());
1677   }
1678 
1679   @Test
updateCustomClassExceptionTest()1680   public void updateCustomClassExceptionTest() throws Exception {
1681     ApiException exception =
1682         ApiExceptionFactory.createException(
1683             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1684     mockService.addException(exception);
1685 
1686     try {
1687       CustomClass customClass =
1688           CustomClass.newBuilder()
1689               .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1690               .setUid("uid115792")
1691               .setDisplayName("displayName1714148973")
1692               .addAllItems(new ArrayList<CustomClass.ClassItem>())
1693               .setCreateTime(Timestamp.newBuilder().build())
1694               .setUpdateTime(Timestamp.newBuilder().build())
1695               .setDeleteTime(Timestamp.newBuilder().build())
1696               .setExpireTime(Timestamp.newBuilder().build())
1697               .putAllAnnotations(new HashMap<String, String>())
1698               .setEtag("etag3123477")
1699               .setReconciling(true)
1700               .setKmsKeyName("kmsKeyName412586233")
1701               .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1702               .build();
1703       FieldMask updateMask = FieldMask.newBuilder().build();
1704       client.updateCustomClassAsync(customClass, updateMask).get();
1705       Assert.fail("No exception raised");
1706     } catch (ExecutionException e) {
1707     }
1708   }
1709 
1710   @Test
deleteCustomClassTest()1711   public void deleteCustomClassTest() throws Exception {
1712     CustomClass expectedResponse =
1713         CustomClass.newBuilder()
1714             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1715             .setUid("uid115792")
1716             .setDisplayName("displayName1714148973")
1717             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1718             .setCreateTime(Timestamp.newBuilder().build())
1719             .setUpdateTime(Timestamp.newBuilder().build())
1720             .setDeleteTime(Timestamp.newBuilder().build())
1721             .setExpireTime(Timestamp.newBuilder().build())
1722             .putAllAnnotations(new HashMap<String, String>())
1723             .setEtag("etag3123477")
1724             .setReconciling(true)
1725             .setKmsKeyName("kmsKeyName412586233")
1726             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1727             .build();
1728     Operation resultOperation =
1729         Operation.newBuilder()
1730             .setName("deleteCustomClassTest")
1731             .setDone(true)
1732             .setResponse(Any.pack(expectedResponse))
1733             .build();
1734     mockService.addResponse(resultOperation);
1735 
1736     CustomClassName name = CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]");
1737 
1738     CustomClass actualResponse = client.deleteCustomClassAsync(name).get();
1739     Assert.assertEquals(expectedResponse, actualResponse);
1740 
1741     List<String> actualRequests = mockService.getRequestPaths();
1742     Assert.assertEquals(1, actualRequests.size());
1743 
1744     String apiClientHeaderKey =
1745         mockService
1746             .getRequestHeaders()
1747             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1748             .iterator()
1749             .next();
1750     Assert.assertTrue(
1751         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1752             .matcher(apiClientHeaderKey)
1753             .matches());
1754   }
1755 
1756   @Test
deleteCustomClassExceptionTest()1757   public void deleteCustomClassExceptionTest() throws Exception {
1758     ApiException exception =
1759         ApiExceptionFactory.createException(
1760             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1761     mockService.addException(exception);
1762 
1763     try {
1764       CustomClassName name = CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]");
1765       client.deleteCustomClassAsync(name).get();
1766       Assert.fail("No exception raised");
1767     } catch (ExecutionException e) {
1768     }
1769   }
1770 
1771   @Test
deleteCustomClassTest2()1772   public void deleteCustomClassTest2() throws Exception {
1773     CustomClass expectedResponse =
1774         CustomClass.newBuilder()
1775             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1776             .setUid("uid115792")
1777             .setDisplayName("displayName1714148973")
1778             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1779             .setCreateTime(Timestamp.newBuilder().build())
1780             .setUpdateTime(Timestamp.newBuilder().build())
1781             .setDeleteTime(Timestamp.newBuilder().build())
1782             .setExpireTime(Timestamp.newBuilder().build())
1783             .putAllAnnotations(new HashMap<String, String>())
1784             .setEtag("etag3123477")
1785             .setReconciling(true)
1786             .setKmsKeyName("kmsKeyName412586233")
1787             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1788             .build();
1789     Operation resultOperation =
1790         Operation.newBuilder()
1791             .setName("deleteCustomClassTest")
1792             .setDone(true)
1793             .setResponse(Any.pack(expectedResponse))
1794             .build();
1795     mockService.addResponse(resultOperation);
1796 
1797     String name = "projects/project-4379/locations/location-4379/customClasses/customClasse-4379";
1798 
1799     CustomClass actualResponse = client.deleteCustomClassAsync(name).get();
1800     Assert.assertEquals(expectedResponse, actualResponse);
1801 
1802     List<String> actualRequests = mockService.getRequestPaths();
1803     Assert.assertEquals(1, actualRequests.size());
1804 
1805     String apiClientHeaderKey =
1806         mockService
1807             .getRequestHeaders()
1808             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1809             .iterator()
1810             .next();
1811     Assert.assertTrue(
1812         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1813             .matcher(apiClientHeaderKey)
1814             .matches());
1815   }
1816 
1817   @Test
deleteCustomClassExceptionTest2()1818   public void deleteCustomClassExceptionTest2() throws Exception {
1819     ApiException exception =
1820         ApiExceptionFactory.createException(
1821             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1822     mockService.addException(exception);
1823 
1824     try {
1825       String name = "projects/project-4379/locations/location-4379/customClasses/customClasse-4379";
1826       client.deleteCustomClassAsync(name).get();
1827       Assert.fail("No exception raised");
1828     } catch (ExecutionException e) {
1829     }
1830   }
1831 
1832   @Test
undeleteCustomClassTest()1833   public void undeleteCustomClassTest() throws Exception {
1834     CustomClass expectedResponse =
1835         CustomClass.newBuilder()
1836             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1837             .setUid("uid115792")
1838             .setDisplayName("displayName1714148973")
1839             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1840             .setCreateTime(Timestamp.newBuilder().build())
1841             .setUpdateTime(Timestamp.newBuilder().build())
1842             .setDeleteTime(Timestamp.newBuilder().build())
1843             .setExpireTime(Timestamp.newBuilder().build())
1844             .putAllAnnotations(new HashMap<String, String>())
1845             .setEtag("etag3123477")
1846             .setReconciling(true)
1847             .setKmsKeyName("kmsKeyName412586233")
1848             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1849             .build();
1850     Operation resultOperation =
1851         Operation.newBuilder()
1852             .setName("undeleteCustomClassTest")
1853             .setDone(true)
1854             .setResponse(Any.pack(expectedResponse))
1855             .build();
1856     mockService.addResponse(resultOperation);
1857 
1858     CustomClassName name = CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]");
1859 
1860     CustomClass actualResponse = client.undeleteCustomClassAsync(name).get();
1861     Assert.assertEquals(expectedResponse, actualResponse);
1862 
1863     List<String> actualRequests = mockService.getRequestPaths();
1864     Assert.assertEquals(1, actualRequests.size());
1865 
1866     String apiClientHeaderKey =
1867         mockService
1868             .getRequestHeaders()
1869             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1870             .iterator()
1871             .next();
1872     Assert.assertTrue(
1873         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1874             .matcher(apiClientHeaderKey)
1875             .matches());
1876   }
1877 
1878   @Test
undeleteCustomClassExceptionTest()1879   public void undeleteCustomClassExceptionTest() throws Exception {
1880     ApiException exception =
1881         ApiExceptionFactory.createException(
1882             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1883     mockService.addException(exception);
1884 
1885     try {
1886       CustomClassName name = CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]");
1887       client.undeleteCustomClassAsync(name).get();
1888       Assert.fail("No exception raised");
1889     } catch (ExecutionException e) {
1890     }
1891   }
1892 
1893   @Test
undeleteCustomClassTest2()1894   public void undeleteCustomClassTest2() throws Exception {
1895     CustomClass expectedResponse =
1896         CustomClass.newBuilder()
1897             .setName(CustomClassName.of("[PROJECT]", "[LOCATION]", "[CUSTOM_CLASS]").toString())
1898             .setUid("uid115792")
1899             .setDisplayName("displayName1714148973")
1900             .addAllItems(new ArrayList<CustomClass.ClassItem>())
1901             .setCreateTime(Timestamp.newBuilder().build())
1902             .setUpdateTime(Timestamp.newBuilder().build())
1903             .setDeleteTime(Timestamp.newBuilder().build())
1904             .setExpireTime(Timestamp.newBuilder().build())
1905             .putAllAnnotations(new HashMap<String, String>())
1906             .setEtag("etag3123477")
1907             .setReconciling(true)
1908             .setKmsKeyName("kmsKeyName412586233")
1909             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1910             .build();
1911     Operation resultOperation =
1912         Operation.newBuilder()
1913             .setName("undeleteCustomClassTest")
1914             .setDone(true)
1915             .setResponse(Any.pack(expectedResponse))
1916             .build();
1917     mockService.addResponse(resultOperation);
1918 
1919     String name = "projects/project-4379/locations/location-4379/customClasses/customClasse-4379";
1920 
1921     CustomClass actualResponse = client.undeleteCustomClassAsync(name).get();
1922     Assert.assertEquals(expectedResponse, actualResponse);
1923 
1924     List<String> actualRequests = mockService.getRequestPaths();
1925     Assert.assertEquals(1, actualRequests.size());
1926 
1927     String apiClientHeaderKey =
1928         mockService
1929             .getRequestHeaders()
1930             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1931             .iterator()
1932             .next();
1933     Assert.assertTrue(
1934         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1935             .matcher(apiClientHeaderKey)
1936             .matches());
1937   }
1938 
1939   @Test
undeleteCustomClassExceptionTest2()1940   public void undeleteCustomClassExceptionTest2() throws Exception {
1941     ApiException exception =
1942         ApiExceptionFactory.createException(
1943             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1944     mockService.addException(exception);
1945 
1946     try {
1947       String name = "projects/project-4379/locations/location-4379/customClasses/customClasse-4379";
1948       client.undeleteCustomClassAsync(name).get();
1949       Assert.fail("No exception raised");
1950     } catch (ExecutionException e) {
1951     }
1952   }
1953 
1954   @Test
createPhraseSetTest()1955   public void createPhraseSetTest() throws Exception {
1956     PhraseSet expectedResponse =
1957         PhraseSet.newBuilder()
1958             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
1959             .setUid("uid115792")
1960             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
1961             .setBoost(93922211)
1962             .setDisplayName("displayName1714148973")
1963             .setCreateTime(Timestamp.newBuilder().build())
1964             .setUpdateTime(Timestamp.newBuilder().build())
1965             .setDeleteTime(Timestamp.newBuilder().build())
1966             .setExpireTime(Timestamp.newBuilder().build())
1967             .putAllAnnotations(new HashMap<String, String>())
1968             .setEtag("etag3123477")
1969             .setReconciling(true)
1970             .setKmsKeyName("kmsKeyName412586233")
1971             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
1972             .build();
1973     Operation resultOperation =
1974         Operation.newBuilder()
1975             .setName("createPhraseSetTest")
1976             .setDone(true)
1977             .setResponse(Any.pack(expectedResponse))
1978             .build();
1979     mockService.addResponse(resultOperation);
1980 
1981     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1982     PhraseSet phraseSet = PhraseSet.newBuilder().build();
1983     String phraseSetId = "phraseSetId959902180";
1984 
1985     PhraseSet actualResponse = client.createPhraseSetAsync(parent, phraseSet, phraseSetId).get();
1986     Assert.assertEquals(expectedResponse, actualResponse);
1987 
1988     List<String> actualRequests = mockService.getRequestPaths();
1989     Assert.assertEquals(1, actualRequests.size());
1990 
1991     String apiClientHeaderKey =
1992         mockService
1993             .getRequestHeaders()
1994             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1995             .iterator()
1996             .next();
1997     Assert.assertTrue(
1998         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1999             .matcher(apiClientHeaderKey)
2000             .matches());
2001   }
2002 
2003   @Test
createPhraseSetExceptionTest()2004   public void createPhraseSetExceptionTest() throws Exception {
2005     ApiException exception =
2006         ApiExceptionFactory.createException(
2007             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2008     mockService.addException(exception);
2009 
2010     try {
2011       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2012       PhraseSet phraseSet = PhraseSet.newBuilder().build();
2013       String phraseSetId = "phraseSetId959902180";
2014       client.createPhraseSetAsync(parent, phraseSet, phraseSetId).get();
2015       Assert.fail("No exception raised");
2016     } catch (ExecutionException e) {
2017     }
2018   }
2019 
2020   @Test
createPhraseSetTest2()2021   public void createPhraseSetTest2() throws Exception {
2022     PhraseSet expectedResponse =
2023         PhraseSet.newBuilder()
2024             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2025             .setUid("uid115792")
2026             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2027             .setBoost(93922211)
2028             .setDisplayName("displayName1714148973")
2029             .setCreateTime(Timestamp.newBuilder().build())
2030             .setUpdateTime(Timestamp.newBuilder().build())
2031             .setDeleteTime(Timestamp.newBuilder().build())
2032             .setExpireTime(Timestamp.newBuilder().build())
2033             .putAllAnnotations(new HashMap<String, String>())
2034             .setEtag("etag3123477")
2035             .setReconciling(true)
2036             .setKmsKeyName("kmsKeyName412586233")
2037             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2038             .build();
2039     Operation resultOperation =
2040         Operation.newBuilder()
2041             .setName("createPhraseSetTest")
2042             .setDone(true)
2043             .setResponse(Any.pack(expectedResponse))
2044             .build();
2045     mockService.addResponse(resultOperation);
2046 
2047     String parent = "projects/project-5833/locations/location-5833";
2048     PhraseSet phraseSet = PhraseSet.newBuilder().build();
2049     String phraseSetId = "phraseSetId959902180";
2050 
2051     PhraseSet actualResponse = client.createPhraseSetAsync(parent, phraseSet, phraseSetId).get();
2052     Assert.assertEquals(expectedResponse, actualResponse);
2053 
2054     List<String> actualRequests = mockService.getRequestPaths();
2055     Assert.assertEquals(1, actualRequests.size());
2056 
2057     String apiClientHeaderKey =
2058         mockService
2059             .getRequestHeaders()
2060             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2061             .iterator()
2062             .next();
2063     Assert.assertTrue(
2064         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2065             .matcher(apiClientHeaderKey)
2066             .matches());
2067   }
2068 
2069   @Test
createPhraseSetExceptionTest2()2070   public void createPhraseSetExceptionTest2() throws Exception {
2071     ApiException exception =
2072         ApiExceptionFactory.createException(
2073             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2074     mockService.addException(exception);
2075 
2076     try {
2077       String parent = "projects/project-5833/locations/location-5833";
2078       PhraseSet phraseSet = PhraseSet.newBuilder().build();
2079       String phraseSetId = "phraseSetId959902180";
2080       client.createPhraseSetAsync(parent, phraseSet, phraseSetId).get();
2081       Assert.fail("No exception raised");
2082     } catch (ExecutionException e) {
2083     }
2084   }
2085 
2086   @Test
listPhraseSetsTest()2087   public void listPhraseSetsTest() throws Exception {
2088     PhraseSet responsesElement = PhraseSet.newBuilder().build();
2089     ListPhraseSetsResponse expectedResponse =
2090         ListPhraseSetsResponse.newBuilder()
2091             .setNextPageToken("")
2092             .addAllPhraseSets(Arrays.asList(responsesElement))
2093             .build();
2094     mockService.addResponse(expectedResponse);
2095 
2096     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2097 
2098     ListPhraseSetsPagedResponse pagedListResponse = client.listPhraseSets(parent);
2099 
2100     List<PhraseSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2101 
2102     Assert.assertEquals(1, resources.size());
2103     Assert.assertEquals(expectedResponse.getPhraseSetsList().get(0), resources.get(0));
2104 
2105     List<String> actualRequests = mockService.getRequestPaths();
2106     Assert.assertEquals(1, actualRequests.size());
2107 
2108     String apiClientHeaderKey =
2109         mockService
2110             .getRequestHeaders()
2111             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2112             .iterator()
2113             .next();
2114     Assert.assertTrue(
2115         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2116             .matcher(apiClientHeaderKey)
2117             .matches());
2118   }
2119 
2120   @Test
listPhraseSetsExceptionTest()2121   public void listPhraseSetsExceptionTest() throws Exception {
2122     ApiException exception =
2123         ApiExceptionFactory.createException(
2124             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2125     mockService.addException(exception);
2126 
2127     try {
2128       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2129       client.listPhraseSets(parent);
2130       Assert.fail("No exception raised");
2131     } catch (InvalidArgumentException e) {
2132       // Expected exception.
2133     }
2134   }
2135 
2136   @Test
listPhraseSetsTest2()2137   public void listPhraseSetsTest2() throws Exception {
2138     PhraseSet responsesElement = PhraseSet.newBuilder().build();
2139     ListPhraseSetsResponse expectedResponse =
2140         ListPhraseSetsResponse.newBuilder()
2141             .setNextPageToken("")
2142             .addAllPhraseSets(Arrays.asList(responsesElement))
2143             .build();
2144     mockService.addResponse(expectedResponse);
2145 
2146     String parent = "projects/project-5833/locations/location-5833";
2147 
2148     ListPhraseSetsPagedResponse pagedListResponse = client.listPhraseSets(parent);
2149 
2150     List<PhraseSet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2151 
2152     Assert.assertEquals(1, resources.size());
2153     Assert.assertEquals(expectedResponse.getPhraseSetsList().get(0), resources.get(0));
2154 
2155     List<String> actualRequests = mockService.getRequestPaths();
2156     Assert.assertEquals(1, actualRequests.size());
2157 
2158     String apiClientHeaderKey =
2159         mockService
2160             .getRequestHeaders()
2161             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2162             .iterator()
2163             .next();
2164     Assert.assertTrue(
2165         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2166             .matcher(apiClientHeaderKey)
2167             .matches());
2168   }
2169 
2170   @Test
listPhraseSetsExceptionTest2()2171   public void listPhraseSetsExceptionTest2() throws Exception {
2172     ApiException exception =
2173         ApiExceptionFactory.createException(
2174             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2175     mockService.addException(exception);
2176 
2177     try {
2178       String parent = "projects/project-5833/locations/location-5833";
2179       client.listPhraseSets(parent);
2180       Assert.fail("No exception raised");
2181     } catch (InvalidArgumentException e) {
2182       // Expected exception.
2183     }
2184   }
2185 
2186   @Test
getPhraseSetTest()2187   public void getPhraseSetTest() throws Exception {
2188     PhraseSet expectedResponse =
2189         PhraseSet.newBuilder()
2190             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2191             .setUid("uid115792")
2192             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2193             .setBoost(93922211)
2194             .setDisplayName("displayName1714148973")
2195             .setCreateTime(Timestamp.newBuilder().build())
2196             .setUpdateTime(Timestamp.newBuilder().build())
2197             .setDeleteTime(Timestamp.newBuilder().build())
2198             .setExpireTime(Timestamp.newBuilder().build())
2199             .putAllAnnotations(new HashMap<String, String>())
2200             .setEtag("etag3123477")
2201             .setReconciling(true)
2202             .setKmsKeyName("kmsKeyName412586233")
2203             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2204             .build();
2205     mockService.addResponse(expectedResponse);
2206 
2207     PhraseSetName name = PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]");
2208 
2209     PhraseSet actualResponse = client.getPhraseSet(name);
2210     Assert.assertEquals(expectedResponse, actualResponse);
2211 
2212     List<String> actualRequests = mockService.getRequestPaths();
2213     Assert.assertEquals(1, actualRequests.size());
2214 
2215     String apiClientHeaderKey =
2216         mockService
2217             .getRequestHeaders()
2218             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2219             .iterator()
2220             .next();
2221     Assert.assertTrue(
2222         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2223             .matcher(apiClientHeaderKey)
2224             .matches());
2225   }
2226 
2227   @Test
getPhraseSetExceptionTest()2228   public void getPhraseSetExceptionTest() throws Exception {
2229     ApiException exception =
2230         ApiExceptionFactory.createException(
2231             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2232     mockService.addException(exception);
2233 
2234     try {
2235       PhraseSetName name = PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]");
2236       client.getPhraseSet(name);
2237       Assert.fail("No exception raised");
2238     } catch (InvalidArgumentException e) {
2239       // Expected exception.
2240     }
2241   }
2242 
2243   @Test
getPhraseSetTest2()2244   public void getPhraseSetTest2() throws Exception {
2245     PhraseSet expectedResponse =
2246         PhraseSet.newBuilder()
2247             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2248             .setUid("uid115792")
2249             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2250             .setBoost(93922211)
2251             .setDisplayName("displayName1714148973")
2252             .setCreateTime(Timestamp.newBuilder().build())
2253             .setUpdateTime(Timestamp.newBuilder().build())
2254             .setDeleteTime(Timestamp.newBuilder().build())
2255             .setExpireTime(Timestamp.newBuilder().build())
2256             .putAllAnnotations(new HashMap<String, String>())
2257             .setEtag("etag3123477")
2258             .setReconciling(true)
2259             .setKmsKeyName("kmsKeyName412586233")
2260             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2261             .build();
2262     mockService.addResponse(expectedResponse);
2263 
2264     String name = "projects/project-458/locations/location-458/phraseSets/phraseSet-458";
2265 
2266     PhraseSet actualResponse = client.getPhraseSet(name);
2267     Assert.assertEquals(expectedResponse, actualResponse);
2268 
2269     List<String> actualRequests = mockService.getRequestPaths();
2270     Assert.assertEquals(1, actualRequests.size());
2271 
2272     String apiClientHeaderKey =
2273         mockService
2274             .getRequestHeaders()
2275             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2276             .iterator()
2277             .next();
2278     Assert.assertTrue(
2279         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2280             .matcher(apiClientHeaderKey)
2281             .matches());
2282   }
2283 
2284   @Test
getPhraseSetExceptionTest2()2285   public void getPhraseSetExceptionTest2() throws Exception {
2286     ApiException exception =
2287         ApiExceptionFactory.createException(
2288             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2289     mockService.addException(exception);
2290 
2291     try {
2292       String name = "projects/project-458/locations/location-458/phraseSets/phraseSet-458";
2293       client.getPhraseSet(name);
2294       Assert.fail("No exception raised");
2295     } catch (InvalidArgumentException e) {
2296       // Expected exception.
2297     }
2298   }
2299 
2300   @Test
updatePhraseSetTest()2301   public void updatePhraseSetTest() throws Exception {
2302     PhraseSet expectedResponse =
2303         PhraseSet.newBuilder()
2304             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2305             .setUid("uid115792")
2306             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2307             .setBoost(93922211)
2308             .setDisplayName("displayName1714148973")
2309             .setCreateTime(Timestamp.newBuilder().build())
2310             .setUpdateTime(Timestamp.newBuilder().build())
2311             .setDeleteTime(Timestamp.newBuilder().build())
2312             .setExpireTime(Timestamp.newBuilder().build())
2313             .putAllAnnotations(new HashMap<String, String>())
2314             .setEtag("etag3123477")
2315             .setReconciling(true)
2316             .setKmsKeyName("kmsKeyName412586233")
2317             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2318             .build();
2319     Operation resultOperation =
2320         Operation.newBuilder()
2321             .setName("updatePhraseSetTest")
2322             .setDone(true)
2323             .setResponse(Any.pack(expectedResponse))
2324             .build();
2325     mockService.addResponse(resultOperation);
2326 
2327     PhraseSet phraseSet =
2328         PhraseSet.newBuilder()
2329             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2330             .setUid("uid115792")
2331             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2332             .setBoost(93922211)
2333             .setDisplayName("displayName1714148973")
2334             .setCreateTime(Timestamp.newBuilder().build())
2335             .setUpdateTime(Timestamp.newBuilder().build())
2336             .setDeleteTime(Timestamp.newBuilder().build())
2337             .setExpireTime(Timestamp.newBuilder().build())
2338             .putAllAnnotations(new HashMap<String, String>())
2339             .setEtag("etag3123477")
2340             .setReconciling(true)
2341             .setKmsKeyName("kmsKeyName412586233")
2342             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2343             .build();
2344     FieldMask updateMask = FieldMask.newBuilder().build();
2345 
2346     PhraseSet actualResponse = client.updatePhraseSetAsync(phraseSet, updateMask).get();
2347     Assert.assertEquals(expectedResponse, actualResponse);
2348 
2349     List<String> actualRequests = mockService.getRequestPaths();
2350     Assert.assertEquals(1, actualRequests.size());
2351 
2352     String apiClientHeaderKey =
2353         mockService
2354             .getRequestHeaders()
2355             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2356             .iterator()
2357             .next();
2358     Assert.assertTrue(
2359         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2360             .matcher(apiClientHeaderKey)
2361             .matches());
2362   }
2363 
2364   @Test
updatePhraseSetExceptionTest()2365   public void updatePhraseSetExceptionTest() throws Exception {
2366     ApiException exception =
2367         ApiExceptionFactory.createException(
2368             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2369     mockService.addException(exception);
2370 
2371     try {
2372       PhraseSet phraseSet =
2373           PhraseSet.newBuilder()
2374               .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2375               .setUid("uid115792")
2376               .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2377               .setBoost(93922211)
2378               .setDisplayName("displayName1714148973")
2379               .setCreateTime(Timestamp.newBuilder().build())
2380               .setUpdateTime(Timestamp.newBuilder().build())
2381               .setDeleteTime(Timestamp.newBuilder().build())
2382               .setExpireTime(Timestamp.newBuilder().build())
2383               .putAllAnnotations(new HashMap<String, String>())
2384               .setEtag("etag3123477")
2385               .setReconciling(true)
2386               .setKmsKeyName("kmsKeyName412586233")
2387               .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2388               .build();
2389       FieldMask updateMask = FieldMask.newBuilder().build();
2390       client.updatePhraseSetAsync(phraseSet, updateMask).get();
2391       Assert.fail("No exception raised");
2392     } catch (ExecutionException e) {
2393     }
2394   }
2395 
2396   @Test
deletePhraseSetTest()2397   public void deletePhraseSetTest() throws Exception {
2398     PhraseSet expectedResponse =
2399         PhraseSet.newBuilder()
2400             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2401             .setUid("uid115792")
2402             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2403             .setBoost(93922211)
2404             .setDisplayName("displayName1714148973")
2405             .setCreateTime(Timestamp.newBuilder().build())
2406             .setUpdateTime(Timestamp.newBuilder().build())
2407             .setDeleteTime(Timestamp.newBuilder().build())
2408             .setExpireTime(Timestamp.newBuilder().build())
2409             .putAllAnnotations(new HashMap<String, String>())
2410             .setEtag("etag3123477")
2411             .setReconciling(true)
2412             .setKmsKeyName("kmsKeyName412586233")
2413             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2414             .build();
2415     Operation resultOperation =
2416         Operation.newBuilder()
2417             .setName("deletePhraseSetTest")
2418             .setDone(true)
2419             .setResponse(Any.pack(expectedResponse))
2420             .build();
2421     mockService.addResponse(resultOperation);
2422 
2423     PhraseSetName name = PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]");
2424 
2425     PhraseSet actualResponse = client.deletePhraseSetAsync(name).get();
2426     Assert.assertEquals(expectedResponse, actualResponse);
2427 
2428     List<String> actualRequests = mockService.getRequestPaths();
2429     Assert.assertEquals(1, actualRequests.size());
2430 
2431     String apiClientHeaderKey =
2432         mockService
2433             .getRequestHeaders()
2434             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2435             .iterator()
2436             .next();
2437     Assert.assertTrue(
2438         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2439             .matcher(apiClientHeaderKey)
2440             .matches());
2441   }
2442 
2443   @Test
deletePhraseSetExceptionTest()2444   public void deletePhraseSetExceptionTest() throws Exception {
2445     ApiException exception =
2446         ApiExceptionFactory.createException(
2447             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2448     mockService.addException(exception);
2449 
2450     try {
2451       PhraseSetName name = PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]");
2452       client.deletePhraseSetAsync(name).get();
2453       Assert.fail("No exception raised");
2454     } catch (ExecutionException e) {
2455     }
2456   }
2457 
2458   @Test
deletePhraseSetTest2()2459   public void deletePhraseSetTest2() throws Exception {
2460     PhraseSet expectedResponse =
2461         PhraseSet.newBuilder()
2462             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2463             .setUid("uid115792")
2464             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2465             .setBoost(93922211)
2466             .setDisplayName("displayName1714148973")
2467             .setCreateTime(Timestamp.newBuilder().build())
2468             .setUpdateTime(Timestamp.newBuilder().build())
2469             .setDeleteTime(Timestamp.newBuilder().build())
2470             .setExpireTime(Timestamp.newBuilder().build())
2471             .putAllAnnotations(new HashMap<String, String>())
2472             .setEtag("etag3123477")
2473             .setReconciling(true)
2474             .setKmsKeyName("kmsKeyName412586233")
2475             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2476             .build();
2477     Operation resultOperation =
2478         Operation.newBuilder()
2479             .setName("deletePhraseSetTest")
2480             .setDone(true)
2481             .setResponse(Any.pack(expectedResponse))
2482             .build();
2483     mockService.addResponse(resultOperation);
2484 
2485     String name = "projects/project-458/locations/location-458/phraseSets/phraseSet-458";
2486 
2487     PhraseSet actualResponse = client.deletePhraseSetAsync(name).get();
2488     Assert.assertEquals(expectedResponse, actualResponse);
2489 
2490     List<String> actualRequests = mockService.getRequestPaths();
2491     Assert.assertEquals(1, actualRequests.size());
2492 
2493     String apiClientHeaderKey =
2494         mockService
2495             .getRequestHeaders()
2496             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2497             .iterator()
2498             .next();
2499     Assert.assertTrue(
2500         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2501             .matcher(apiClientHeaderKey)
2502             .matches());
2503   }
2504 
2505   @Test
deletePhraseSetExceptionTest2()2506   public void deletePhraseSetExceptionTest2() throws Exception {
2507     ApiException exception =
2508         ApiExceptionFactory.createException(
2509             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2510     mockService.addException(exception);
2511 
2512     try {
2513       String name = "projects/project-458/locations/location-458/phraseSets/phraseSet-458";
2514       client.deletePhraseSetAsync(name).get();
2515       Assert.fail("No exception raised");
2516     } catch (ExecutionException e) {
2517     }
2518   }
2519 
2520   @Test
undeletePhraseSetTest()2521   public void undeletePhraseSetTest() throws Exception {
2522     PhraseSet expectedResponse =
2523         PhraseSet.newBuilder()
2524             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2525             .setUid("uid115792")
2526             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2527             .setBoost(93922211)
2528             .setDisplayName("displayName1714148973")
2529             .setCreateTime(Timestamp.newBuilder().build())
2530             .setUpdateTime(Timestamp.newBuilder().build())
2531             .setDeleteTime(Timestamp.newBuilder().build())
2532             .setExpireTime(Timestamp.newBuilder().build())
2533             .putAllAnnotations(new HashMap<String, String>())
2534             .setEtag("etag3123477")
2535             .setReconciling(true)
2536             .setKmsKeyName("kmsKeyName412586233")
2537             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2538             .build();
2539     Operation resultOperation =
2540         Operation.newBuilder()
2541             .setName("undeletePhraseSetTest")
2542             .setDone(true)
2543             .setResponse(Any.pack(expectedResponse))
2544             .build();
2545     mockService.addResponse(resultOperation);
2546 
2547     PhraseSetName name = PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]");
2548 
2549     PhraseSet actualResponse = client.undeletePhraseSetAsync(name).get();
2550     Assert.assertEquals(expectedResponse, actualResponse);
2551 
2552     List<String> actualRequests = mockService.getRequestPaths();
2553     Assert.assertEquals(1, actualRequests.size());
2554 
2555     String apiClientHeaderKey =
2556         mockService
2557             .getRequestHeaders()
2558             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2559             .iterator()
2560             .next();
2561     Assert.assertTrue(
2562         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2563             .matcher(apiClientHeaderKey)
2564             .matches());
2565   }
2566 
2567   @Test
undeletePhraseSetExceptionTest()2568   public void undeletePhraseSetExceptionTest() throws Exception {
2569     ApiException exception =
2570         ApiExceptionFactory.createException(
2571             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2572     mockService.addException(exception);
2573 
2574     try {
2575       PhraseSetName name = PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]");
2576       client.undeletePhraseSetAsync(name).get();
2577       Assert.fail("No exception raised");
2578     } catch (ExecutionException e) {
2579     }
2580   }
2581 
2582   @Test
undeletePhraseSetTest2()2583   public void undeletePhraseSetTest2() throws Exception {
2584     PhraseSet expectedResponse =
2585         PhraseSet.newBuilder()
2586             .setName(PhraseSetName.of("[PROJECT]", "[LOCATION]", "[PHRASE_SET]").toString())
2587             .setUid("uid115792")
2588             .addAllPhrases(new ArrayList<PhraseSet.Phrase>())
2589             .setBoost(93922211)
2590             .setDisplayName("displayName1714148973")
2591             .setCreateTime(Timestamp.newBuilder().build())
2592             .setUpdateTime(Timestamp.newBuilder().build())
2593             .setDeleteTime(Timestamp.newBuilder().build())
2594             .setExpireTime(Timestamp.newBuilder().build())
2595             .putAllAnnotations(new HashMap<String, String>())
2596             .setEtag("etag3123477")
2597             .setReconciling(true)
2598             .setKmsKeyName("kmsKeyName412586233")
2599             .setKmsKeyVersionName("kmsKeyVersionName-1798811307")
2600             .build();
2601     Operation resultOperation =
2602         Operation.newBuilder()
2603             .setName("undeletePhraseSetTest")
2604             .setDone(true)
2605             .setResponse(Any.pack(expectedResponse))
2606             .build();
2607     mockService.addResponse(resultOperation);
2608 
2609     String name = "projects/project-458/locations/location-458/phraseSets/phraseSet-458";
2610 
2611     PhraseSet actualResponse = client.undeletePhraseSetAsync(name).get();
2612     Assert.assertEquals(expectedResponse, actualResponse);
2613 
2614     List<String> actualRequests = mockService.getRequestPaths();
2615     Assert.assertEquals(1, actualRequests.size());
2616 
2617     String apiClientHeaderKey =
2618         mockService
2619             .getRequestHeaders()
2620             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2621             .iterator()
2622             .next();
2623     Assert.assertTrue(
2624         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2625             .matcher(apiClientHeaderKey)
2626             .matches());
2627   }
2628 
2629   @Test
undeletePhraseSetExceptionTest2()2630   public void undeletePhraseSetExceptionTest2() throws Exception {
2631     ApiException exception =
2632         ApiExceptionFactory.createException(
2633             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2634     mockService.addException(exception);
2635 
2636     try {
2637       String name = "projects/project-458/locations/location-458/phraseSets/phraseSet-458";
2638       client.undeletePhraseSetAsync(name).get();
2639       Assert.fail("No exception raised");
2640     } catch (ExecutionException e) {
2641     }
2642   }
2643 
2644   @Test
listLocationsTest()2645   public void listLocationsTest() throws Exception {
2646     Location responsesElement = Location.newBuilder().build();
2647     ListLocationsResponse expectedResponse =
2648         ListLocationsResponse.newBuilder()
2649             .setNextPageToken("")
2650             .addAllLocations(Arrays.asList(responsesElement))
2651             .build();
2652     mockService.addResponse(expectedResponse);
2653 
2654     ListLocationsRequest request =
2655         ListLocationsRequest.newBuilder()
2656             .setName("projects/project-3664")
2657             .setFilter("filter-1274492040")
2658             .setPageSize(883849137)
2659             .setPageToken("pageToken873572522")
2660             .build();
2661 
2662     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2663 
2664     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2665 
2666     Assert.assertEquals(1, resources.size());
2667     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2668 
2669     List<String> actualRequests = mockService.getRequestPaths();
2670     Assert.assertEquals(1, actualRequests.size());
2671 
2672     String apiClientHeaderKey =
2673         mockService
2674             .getRequestHeaders()
2675             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2676             .iterator()
2677             .next();
2678     Assert.assertTrue(
2679         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2680             .matcher(apiClientHeaderKey)
2681             .matches());
2682   }
2683 
2684   @Test
listLocationsExceptionTest()2685   public void listLocationsExceptionTest() throws Exception {
2686     ApiException exception =
2687         ApiExceptionFactory.createException(
2688             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2689     mockService.addException(exception);
2690 
2691     try {
2692       ListLocationsRequest request =
2693           ListLocationsRequest.newBuilder()
2694               .setName("projects/project-3664")
2695               .setFilter("filter-1274492040")
2696               .setPageSize(883849137)
2697               .setPageToken("pageToken873572522")
2698               .build();
2699       client.listLocations(request);
2700       Assert.fail("No exception raised");
2701     } catch (InvalidArgumentException e) {
2702       // Expected exception.
2703     }
2704   }
2705 
2706   @Test
getLocationTest()2707   public void getLocationTest() throws Exception {
2708     Location expectedResponse =
2709         Location.newBuilder()
2710             .setName("name3373707")
2711             .setLocationId("locationId1541836720")
2712             .setDisplayName("displayName1714148973")
2713             .putAllLabels(new HashMap<String, String>())
2714             .setMetadata(Any.newBuilder().build())
2715             .build();
2716     mockService.addResponse(expectedResponse);
2717 
2718     GetLocationRequest request =
2719         GetLocationRequest.newBuilder()
2720             .setName("projects/project-9062/locations/location-9062")
2721             .build();
2722 
2723     Location actualResponse = client.getLocation(request);
2724     Assert.assertEquals(expectedResponse, actualResponse);
2725 
2726     List<String> actualRequests = mockService.getRequestPaths();
2727     Assert.assertEquals(1, actualRequests.size());
2728 
2729     String apiClientHeaderKey =
2730         mockService
2731             .getRequestHeaders()
2732             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2733             .iterator()
2734             .next();
2735     Assert.assertTrue(
2736         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2737             .matcher(apiClientHeaderKey)
2738             .matches());
2739   }
2740 
2741   @Test
getLocationExceptionTest()2742   public void getLocationExceptionTest() throws Exception {
2743     ApiException exception =
2744         ApiExceptionFactory.createException(
2745             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2746     mockService.addException(exception);
2747 
2748     try {
2749       GetLocationRequest request =
2750           GetLocationRequest.newBuilder()
2751               .setName("projects/project-9062/locations/location-9062")
2752               .build();
2753       client.getLocation(request);
2754       Assert.fail("No exception raised");
2755     } catch (InvalidArgumentException e) {
2756       // Expected exception.
2757     }
2758   }
2759 }
2760