• 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.vmwareengine.v1;
18 
19 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListClustersPagedResponse;
20 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListHcxActivationKeysPagedResponse;
21 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListLocationsPagedResponse;
22 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListNetworkPoliciesPagedResponse;
23 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListNodeTypesPagedResponse;
24 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListPrivateCloudsPagedResponse;
25 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListSubnetsPagedResponse;
26 import static com.google.cloud.vmwareengine.v1.VmwareEngineClient.ListVmwareEngineNetworksPagedResponse;
27 
28 import com.google.api.gax.core.NoCredentialsProvider;
29 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
30 import com.google.api.gax.httpjson.testing.MockHttpService;
31 import com.google.api.gax.rpc.ApiClientHeaderProvider;
32 import com.google.api.gax.rpc.ApiException;
33 import com.google.api.gax.rpc.ApiExceptionFactory;
34 import com.google.api.gax.rpc.InvalidArgumentException;
35 import com.google.api.gax.rpc.StatusCode;
36 import com.google.api.gax.rpc.testing.FakeStatusCode;
37 import com.google.cloud.location.GetLocationRequest;
38 import com.google.cloud.location.ListLocationsRequest;
39 import com.google.cloud.location.ListLocationsResponse;
40 import com.google.cloud.location.Location;
41 import com.google.cloud.vmwareengine.v1.stub.HttpJsonVmwareEngineStub;
42 import com.google.common.collect.Lists;
43 import com.google.iam.v1.AuditConfig;
44 import com.google.iam.v1.Binding;
45 import com.google.iam.v1.GetIamPolicyRequest;
46 import com.google.iam.v1.GetPolicyOptions;
47 import com.google.iam.v1.Policy;
48 import com.google.iam.v1.SetIamPolicyRequest;
49 import com.google.iam.v1.TestIamPermissionsRequest;
50 import com.google.iam.v1.TestIamPermissionsResponse;
51 import com.google.longrunning.Operation;
52 import com.google.protobuf.Any;
53 import com.google.protobuf.ByteString;
54 import com.google.protobuf.Empty;
55 import com.google.protobuf.FieldMask;
56 import com.google.protobuf.Timestamp;
57 import java.io.IOException;
58 import java.util.ArrayList;
59 import java.util.Arrays;
60 import java.util.HashMap;
61 import java.util.List;
62 import java.util.concurrent.ExecutionException;
63 import javax.annotation.Generated;
64 import org.junit.After;
65 import org.junit.AfterClass;
66 import org.junit.Assert;
67 import org.junit.Before;
68 import org.junit.BeforeClass;
69 import org.junit.Test;
70 
71 @Generated("by gapic-generator-java")
72 public class VmwareEngineClientHttpJsonTest {
73   private static MockHttpService mockService;
74   private static VmwareEngineClient client;
75 
76   @BeforeClass
startStaticServer()77   public static void startStaticServer() throws IOException {
78     mockService =
79         new MockHttpService(
80             HttpJsonVmwareEngineStub.getMethodDescriptors(),
81             VmwareEngineSettings.getDefaultEndpoint());
82     VmwareEngineSettings settings =
83         VmwareEngineSettings.newHttpJsonBuilder()
84             .setTransportChannelProvider(
85                 VmwareEngineSettings.defaultHttpJsonTransportProviderBuilder()
86                     .setHttpTransport(mockService)
87                     .build())
88             .setCredentialsProvider(NoCredentialsProvider.create())
89             .build();
90     client = VmwareEngineClient.create(settings);
91   }
92 
93   @AfterClass
stopServer()94   public static void stopServer() {
95     client.close();
96   }
97 
98   @Before
setUp()99   public void setUp() {}
100 
101   @After
tearDown()102   public void tearDown() throws Exception {
103     mockService.reset();
104   }
105 
106   @Test
listPrivateCloudsTest()107   public void listPrivateCloudsTest() throws Exception {
108     PrivateCloud responsesElement = PrivateCloud.newBuilder().build();
109     ListPrivateCloudsResponse expectedResponse =
110         ListPrivateCloudsResponse.newBuilder()
111             .setNextPageToken("")
112             .addAllPrivateClouds(Arrays.asList(responsesElement))
113             .build();
114     mockService.addResponse(expectedResponse);
115 
116     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
117 
118     ListPrivateCloudsPagedResponse pagedListResponse = client.listPrivateClouds(parent);
119 
120     List<PrivateCloud> resources = Lists.newArrayList(pagedListResponse.iterateAll());
121 
122     Assert.assertEquals(1, resources.size());
123     Assert.assertEquals(expectedResponse.getPrivateCloudsList().get(0), resources.get(0));
124 
125     List<String> actualRequests = mockService.getRequestPaths();
126     Assert.assertEquals(1, actualRequests.size());
127 
128     String apiClientHeaderKey =
129         mockService
130             .getRequestHeaders()
131             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
132             .iterator()
133             .next();
134     Assert.assertTrue(
135         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
136             .matcher(apiClientHeaderKey)
137             .matches());
138   }
139 
140   @Test
listPrivateCloudsExceptionTest()141   public void listPrivateCloudsExceptionTest() throws Exception {
142     ApiException exception =
143         ApiExceptionFactory.createException(
144             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
145     mockService.addException(exception);
146 
147     try {
148       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
149       client.listPrivateClouds(parent);
150       Assert.fail("No exception raised");
151     } catch (InvalidArgumentException e) {
152       // Expected exception.
153     }
154   }
155 
156   @Test
listPrivateCloudsTest2()157   public void listPrivateCloudsTest2() throws Exception {
158     PrivateCloud responsesElement = PrivateCloud.newBuilder().build();
159     ListPrivateCloudsResponse expectedResponse =
160         ListPrivateCloudsResponse.newBuilder()
161             .setNextPageToken("")
162             .addAllPrivateClouds(Arrays.asList(responsesElement))
163             .build();
164     mockService.addResponse(expectedResponse);
165 
166     String parent = "projects/project-5833/locations/location-5833";
167 
168     ListPrivateCloudsPagedResponse pagedListResponse = client.listPrivateClouds(parent);
169 
170     List<PrivateCloud> resources = Lists.newArrayList(pagedListResponse.iterateAll());
171 
172     Assert.assertEquals(1, resources.size());
173     Assert.assertEquals(expectedResponse.getPrivateCloudsList().get(0), resources.get(0));
174 
175     List<String> actualRequests = mockService.getRequestPaths();
176     Assert.assertEquals(1, actualRequests.size());
177 
178     String apiClientHeaderKey =
179         mockService
180             .getRequestHeaders()
181             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
182             .iterator()
183             .next();
184     Assert.assertTrue(
185         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
186             .matcher(apiClientHeaderKey)
187             .matches());
188   }
189 
190   @Test
listPrivateCloudsExceptionTest2()191   public void listPrivateCloudsExceptionTest2() throws Exception {
192     ApiException exception =
193         ApiExceptionFactory.createException(
194             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
195     mockService.addException(exception);
196 
197     try {
198       String parent = "projects/project-5833/locations/location-5833";
199       client.listPrivateClouds(parent);
200       Assert.fail("No exception raised");
201     } catch (InvalidArgumentException e) {
202       // Expected exception.
203     }
204   }
205 
206   @Test
getPrivateCloudTest()207   public void getPrivateCloudTest() throws Exception {
208     PrivateCloud expectedResponse =
209         PrivateCloud.newBuilder()
210             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
211             .setCreateTime(Timestamp.newBuilder().build())
212             .setUpdateTime(Timestamp.newBuilder().build())
213             .setDeleteTime(Timestamp.newBuilder().build())
214             .setExpireTime(Timestamp.newBuilder().build())
215             .setNetworkConfig(NetworkConfig.newBuilder().build())
216             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
217             .setDescription("description-1724546052")
218             .setHcx(Hcx.newBuilder().build())
219             .setNsx(Nsx.newBuilder().build())
220             .setVcenter(Vcenter.newBuilder().build())
221             .setUid("uid115792")
222             .build();
223     mockService.addResponse(expectedResponse);
224 
225     PrivateCloudName name = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
226 
227     PrivateCloud actualResponse = client.getPrivateCloud(name);
228     Assert.assertEquals(expectedResponse, actualResponse);
229 
230     List<String> actualRequests = mockService.getRequestPaths();
231     Assert.assertEquals(1, actualRequests.size());
232 
233     String apiClientHeaderKey =
234         mockService
235             .getRequestHeaders()
236             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
237             .iterator()
238             .next();
239     Assert.assertTrue(
240         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
241             .matcher(apiClientHeaderKey)
242             .matches());
243   }
244 
245   @Test
getPrivateCloudExceptionTest()246   public void getPrivateCloudExceptionTest() throws Exception {
247     ApiException exception =
248         ApiExceptionFactory.createException(
249             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
250     mockService.addException(exception);
251 
252     try {
253       PrivateCloudName name = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
254       client.getPrivateCloud(name);
255       Assert.fail("No exception raised");
256     } catch (InvalidArgumentException e) {
257       // Expected exception.
258     }
259   }
260 
261   @Test
getPrivateCloudTest2()262   public void getPrivateCloudTest2() throws Exception {
263     PrivateCloud expectedResponse =
264         PrivateCloud.newBuilder()
265             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
266             .setCreateTime(Timestamp.newBuilder().build())
267             .setUpdateTime(Timestamp.newBuilder().build())
268             .setDeleteTime(Timestamp.newBuilder().build())
269             .setExpireTime(Timestamp.newBuilder().build())
270             .setNetworkConfig(NetworkConfig.newBuilder().build())
271             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
272             .setDescription("description-1724546052")
273             .setHcx(Hcx.newBuilder().build())
274             .setNsx(Nsx.newBuilder().build())
275             .setVcenter(Vcenter.newBuilder().build())
276             .setUid("uid115792")
277             .build();
278     mockService.addResponse(expectedResponse);
279 
280     String name = "projects/project-6537/locations/location-6537/privateClouds/privateCloud-6537";
281 
282     PrivateCloud actualResponse = client.getPrivateCloud(name);
283     Assert.assertEquals(expectedResponse, actualResponse);
284 
285     List<String> actualRequests = mockService.getRequestPaths();
286     Assert.assertEquals(1, actualRequests.size());
287 
288     String apiClientHeaderKey =
289         mockService
290             .getRequestHeaders()
291             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
292             .iterator()
293             .next();
294     Assert.assertTrue(
295         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
296             .matcher(apiClientHeaderKey)
297             .matches());
298   }
299 
300   @Test
getPrivateCloudExceptionTest2()301   public void getPrivateCloudExceptionTest2() throws Exception {
302     ApiException exception =
303         ApiExceptionFactory.createException(
304             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
305     mockService.addException(exception);
306 
307     try {
308       String name = "projects/project-6537/locations/location-6537/privateClouds/privateCloud-6537";
309       client.getPrivateCloud(name);
310       Assert.fail("No exception raised");
311     } catch (InvalidArgumentException e) {
312       // Expected exception.
313     }
314   }
315 
316   @Test
createPrivateCloudTest()317   public void createPrivateCloudTest() throws Exception {
318     PrivateCloud expectedResponse =
319         PrivateCloud.newBuilder()
320             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
321             .setCreateTime(Timestamp.newBuilder().build())
322             .setUpdateTime(Timestamp.newBuilder().build())
323             .setDeleteTime(Timestamp.newBuilder().build())
324             .setExpireTime(Timestamp.newBuilder().build())
325             .setNetworkConfig(NetworkConfig.newBuilder().build())
326             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
327             .setDescription("description-1724546052")
328             .setHcx(Hcx.newBuilder().build())
329             .setNsx(Nsx.newBuilder().build())
330             .setVcenter(Vcenter.newBuilder().build())
331             .setUid("uid115792")
332             .build();
333     Operation resultOperation =
334         Operation.newBuilder()
335             .setName("createPrivateCloudTest")
336             .setDone(true)
337             .setResponse(Any.pack(expectedResponse))
338             .build();
339     mockService.addResponse(resultOperation);
340 
341     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
342     PrivateCloud privateCloud = PrivateCloud.newBuilder().build();
343     String privateCloudId = "privateCloudId573896493";
344 
345     PrivateCloud actualResponse =
346         client.createPrivateCloudAsync(parent, privateCloud, privateCloudId).get();
347     Assert.assertEquals(expectedResponse, actualResponse);
348 
349     List<String> actualRequests = mockService.getRequestPaths();
350     Assert.assertEquals(1, actualRequests.size());
351 
352     String apiClientHeaderKey =
353         mockService
354             .getRequestHeaders()
355             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
356             .iterator()
357             .next();
358     Assert.assertTrue(
359         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
360             .matcher(apiClientHeaderKey)
361             .matches());
362   }
363 
364   @Test
createPrivateCloudExceptionTest()365   public void createPrivateCloudExceptionTest() throws Exception {
366     ApiException exception =
367         ApiExceptionFactory.createException(
368             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
369     mockService.addException(exception);
370 
371     try {
372       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
373       PrivateCloud privateCloud = PrivateCloud.newBuilder().build();
374       String privateCloudId = "privateCloudId573896493";
375       client.createPrivateCloudAsync(parent, privateCloud, privateCloudId).get();
376       Assert.fail("No exception raised");
377     } catch (ExecutionException e) {
378     }
379   }
380 
381   @Test
createPrivateCloudTest2()382   public void createPrivateCloudTest2() throws Exception {
383     PrivateCloud expectedResponse =
384         PrivateCloud.newBuilder()
385             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
386             .setCreateTime(Timestamp.newBuilder().build())
387             .setUpdateTime(Timestamp.newBuilder().build())
388             .setDeleteTime(Timestamp.newBuilder().build())
389             .setExpireTime(Timestamp.newBuilder().build())
390             .setNetworkConfig(NetworkConfig.newBuilder().build())
391             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
392             .setDescription("description-1724546052")
393             .setHcx(Hcx.newBuilder().build())
394             .setNsx(Nsx.newBuilder().build())
395             .setVcenter(Vcenter.newBuilder().build())
396             .setUid("uid115792")
397             .build();
398     Operation resultOperation =
399         Operation.newBuilder()
400             .setName("createPrivateCloudTest")
401             .setDone(true)
402             .setResponse(Any.pack(expectedResponse))
403             .build();
404     mockService.addResponse(resultOperation);
405 
406     String parent = "projects/project-5833/locations/location-5833";
407     PrivateCloud privateCloud = PrivateCloud.newBuilder().build();
408     String privateCloudId = "privateCloudId573896493";
409 
410     PrivateCloud actualResponse =
411         client.createPrivateCloudAsync(parent, privateCloud, privateCloudId).get();
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
createPrivateCloudExceptionTest2()430   public void createPrivateCloudExceptionTest2() 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 parent = "projects/project-5833/locations/location-5833";
438       PrivateCloud privateCloud = PrivateCloud.newBuilder().build();
439       String privateCloudId = "privateCloudId573896493";
440       client.createPrivateCloudAsync(parent, privateCloud, privateCloudId).get();
441       Assert.fail("No exception raised");
442     } catch (ExecutionException e) {
443     }
444   }
445 
446   @Test
updatePrivateCloudTest()447   public void updatePrivateCloudTest() throws Exception {
448     PrivateCloud expectedResponse =
449         PrivateCloud.newBuilder()
450             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
451             .setCreateTime(Timestamp.newBuilder().build())
452             .setUpdateTime(Timestamp.newBuilder().build())
453             .setDeleteTime(Timestamp.newBuilder().build())
454             .setExpireTime(Timestamp.newBuilder().build())
455             .setNetworkConfig(NetworkConfig.newBuilder().build())
456             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
457             .setDescription("description-1724546052")
458             .setHcx(Hcx.newBuilder().build())
459             .setNsx(Nsx.newBuilder().build())
460             .setVcenter(Vcenter.newBuilder().build())
461             .setUid("uid115792")
462             .build();
463     Operation resultOperation =
464         Operation.newBuilder()
465             .setName("updatePrivateCloudTest")
466             .setDone(true)
467             .setResponse(Any.pack(expectedResponse))
468             .build();
469     mockService.addResponse(resultOperation);
470 
471     PrivateCloud privateCloud =
472         PrivateCloud.newBuilder()
473             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
474             .setCreateTime(Timestamp.newBuilder().build())
475             .setUpdateTime(Timestamp.newBuilder().build())
476             .setDeleteTime(Timestamp.newBuilder().build())
477             .setExpireTime(Timestamp.newBuilder().build())
478             .setNetworkConfig(NetworkConfig.newBuilder().build())
479             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
480             .setDescription("description-1724546052")
481             .setHcx(Hcx.newBuilder().build())
482             .setNsx(Nsx.newBuilder().build())
483             .setVcenter(Vcenter.newBuilder().build())
484             .setUid("uid115792")
485             .build();
486     FieldMask updateMask = FieldMask.newBuilder().build();
487 
488     PrivateCloud actualResponse = client.updatePrivateCloudAsync(privateCloud, updateMask).get();
489     Assert.assertEquals(expectedResponse, actualResponse);
490 
491     List<String> actualRequests = mockService.getRequestPaths();
492     Assert.assertEquals(1, actualRequests.size());
493 
494     String apiClientHeaderKey =
495         mockService
496             .getRequestHeaders()
497             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
498             .iterator()
499             .next();
500     Assert.assertTrue(
501         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
502             .matcher(apiClientHeaderKey)
503             .matches());
504   }
505 
506   @Test
updatePrivateCloudExceptionTest()507   public void updatePrivateCloudExceptionTest() throws Exception {
508     ApiException exception =
509         ApiExceptionFactory.createException(
510             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
511     mockService.addException(exception);
512 
513     try {
514       PrivateCloud privateCloud =
515           PrivateCloud.newBuilder()
516               .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
517               .setCreateTime(Timestamp.newBuilder().build())
518               .setUpdateTime(Timestamp.newBuilder().build())
519               .setDeleteTime(Timestamp.newBuilder().build())
520               .setExpireTime(Timestamp.newBuilder().build())
521               .setNetworkConfig(NetworkConfig.newBuilder().build())
522               .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
523               .setDescription("description-1724546052")
524               .setHcx(Hcx.newBuilder().build())
525               .setNsx(Nsx.newBuilder().build())
526               .setVcenter(Vcenter.newBuilder().build())
527               .setUid("uid115792")
528               .build();
529       FieldMask updateMask = FieldMask.newBuilder().build();
530       client.updatePrivateCloudAsync(privateCloud, updateMask).get();
531       Assert.fail("No exception raised");
532     } catch (ExecutionException e) {
533     }
534   }
535 
536   @Test
deletePrivateCloudTest()537   public void deletePrivateCloudTest() throws Exception {
538     PrivateCloud expectedResponse =
539         PrivateCloud.newBuilder()
540             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
541             .setCreateTime(Timestamp.newBuilder().build())
542             .setUpdateTime(Timestamp.newBuilder().build())
543             .setDeleteTime(Timestamp.newBuilder().build())
544             .setExpireTime(Timestamp.newBuilder().build())
545             .setNetworkConfig(NetworkConfig.newBuilder().build())
546             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
547             .setDescription("description-1724546052")
548             .setHcx(Hcx.newBuilder().build())
549             .setNsx(Nsx.newBuilder().build())
550             .setVcenter(Vcenter.newBuilder().build())
551             .setUid("uid115792")
552             .build();
553     Operation resultOperation =
554         Operation.newBuilder()
555             .setName("deletePrivateCloudTest")
556             .setDone(true)
557             .setResponse(Any.pack(expectedResponse))
558             .build();
559     mockService.addResponse(resultOperation);
560 
561     PrivateCloudName name = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
562 
563     PrivateCloud actualResponse = client.deletePrivateCloudAsync(name).get();
564     Assert.assertEquals(expectedResponse, actualResponse);
565 
566     List<String> actualRequests = mockService.getRequestPaths();
567     Assert.assertEquals(1, actualRequests.size());
568 
569     String apiClientHeaderKey =
570         mockService
571             .getRequestHeaders()
572             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
573             .iterator()
574             .next();
575     Assert.assertTrue(
576         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
577             .matcher(apiClientHeaderKey)
578             .matches());
579   }
580 
581   @Test
deletePrivateCloudExceptionTest()582   public void deletePrivateCloudExceptionTest() throws Exception {
583     ApiException exception =
584         ApiExceptionFactory.createException(
585             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
586     mockService.addException(exception);
587 
588     try {
589       PrivateCloudName name = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
590       client.deletePrivateCloudAsync(name).get();
591       Assert.fail("No exception raised");
592     } catch (ExecutionException e) {
593     }
594   }
595 
596   @Test
deletePrivateCloudTest2()597   public void deletePrivateCloudTest2() throws Exception {
598     PrivateCloud expectedResponse =
599         PrivateCloud.newBuilder()
600             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
601             .setCreateTime(Timestamp.newBuilder().build())
602             .setUpdateTime(Timestamp.newBuilder().build())
603             .setDeleteTime(Timestamp.newBuilder().build())
604             .setExpireTime(Timestamp.newBuilder().build())
605             .setNetworkConfig(NetworkConfig.newBuilder().build())
606             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
607             .setDescription("description-1724546052")
608             .setHcx(Hcx.newBuilder().build())
609             .setNsx(Nsx.newBuilder().build())
610             .setVcenter(Vcenter.newBuilder().build())
611             .setUid("uid115792")
612             .build();
613     Operation resultOperation =
614         Operation.newBuilder()
615             .setName("deletePrivateCloudTest")
616             .setDone(true)
617             .setResponse(Any.pack(expectedResponse))
618             .build();
619     mockService.addResponse(resultOperation);
620 
621     String name = "projects/project-6537/locations/location-6537/privateClouds/privateCloud-6537";
622 
623     PrivateCloud actualResponse = client.deletePrivateCloudAsync(name).get();
624     Assert.assertEquals(expectedResponse, actualResponse);
625 
626     List<String> actualRequests = mockService.getRequestPaths();
627     Assert.assertEquals(1, actualRequests.size());
628 
629     String apiClientHeaderKey =
630         mockService
631             .getRequestHeaders()
632             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
633             .iterator()
634             .next();
635     Assert.assertTrue(
636         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
637             .matcher(apiClientHeaderKey)
638             .matches());
639   }
640 
641   @Test
deletePrivateCloudExceptionTest2()642   public void deletePrivateCloudExceptionTest2() throws Exception {
643     ApiException exception =
644         ApiExceptionFactory.createException(
645             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
646     mockService.addException(exception);
647 
648     try {
649       String name = "projects/project-6537/locations/location-6537/privateClouds/privateCloud-6537";
650       client.deletePrivateCloudAsync(name).get();
651       Assert.fail("No exception raised");
652     } catch (ExecutionException e) {
653     }
654   }
655 
656   @Test
undeletePrivateCloudTest()657   public void undeletePrivateCloudTest() throws Exception {
658     PrivateCloud expectedResponse =
659         PrivateCloud.newBuilder()
660             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
661             .setCreateTime(Timestamp.newBuilder().build())
662             .setUpdateTime(Timestamp.newBuilder().build())
663             .setDeleteTime(Timestamp.newBuilder().build())
664             .setExpireTime(Timestamp.newBuilder().build())
665             .setNetworkConfig(NetworkConfig.newBuilder().build())
666             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
667             .setDescription("description-1724546052")
668             .setHcx(Hcx.newBuilder().build())
669             .setNsx(Nsx.newBuilder().build())
670             .setVcenter(Vcenter.newBuilder().build())
671             .setUid("uid115792")
672             .build();
673     Operation resultOperation =
674         Operation.newBuilder()
675             .setName("undeletePrivateCloudTest")
676             .setDone(true)
677             .setResponse(Any.pack(expectedResponse))
678             .build();
679     mockService.addResponse(resultOperation);
680 
681     PrivateCloudName name = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
682 
683     PrivateCloud actualResponse = client.undeletePrivateCloudAsync(name).get();
684     Assert.assertEquals(expectedResponse, actualResponse);
685 
686     List<String> actualRequests = mockService.getRequestPaths();
687     Assert.assertEquals(1, actualRequests.size());
688 
689     String apiClientHeaderKey =
690         mockService
691             .getRequestHeaders()
692             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
693             .iterator()
694             .next();
695     Assert.assertTrue(
696         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
697             .matcher(apiClientHeaderKey)
698             .matches());
699   }
700 
701   @Test
undeletePrivateCloudExceptionTest()702   public void undeletePrivateCloudExceptionTest() throws Exception {
703     ApiException exception =
704         ApiExceptionFactory.createException(
705             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
706     mockService.addException(exception);
707 
708     try {
709       PrivateCloudName name = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
710       client.undeletePrivateCloudAsync(name).get();
711       Assert.fail("No exception raised");
712     } catch (ExecutionException e) {
713     }
714   }
715 
716   @Test
undeletePrivateCloudTest2()717   public void undeletePrivateCloudTest2() throws Exception {
718     PrivateCloud expectedResponse =
719         PrivateCloud.newBuilder()
720             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
721             .setCreateTime(Timestamp.newBuilder().build())
722             .setUpdateTime(Timestamp.newBuilder().build())
723             .setDeleteTime(Timestamp.newBuilder().build())
724             .setExpireTime(Timestamp.newBuilder().build())
725             .setNetworkConfig(NetworkConfig.newBuilder().build())
726             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
727             .setDescription("description-1724546052")
728             .setHcx(Hcx.newBuilder().build())
729             .setNsx(Nsx.newBuilder().build())
730             .setVcenter(Vcenter.newBuilder().build())
731             .setUid("uid115792")
732             .build();
733     Operation resultOperation =
734         Operation.newBuilder()
735             .setName("undeletePrivateCloudTest")
736             .setDone(true)
737             .setResponse(Any.pack(expectedResponse))
738             .build();
739     mockService.addResponse(resultOperation);
740 
741     String name = "projects/project-6537/locations/location-6537/privateClouds/privateCloud-6537";
742 
743     PrivateCloud actualResponse = client.undeletePrivateCloudAsync(name).get();
744     Assert.assertEquals(expectedResponse, actualResponse);
745 
746     List<String> actualRequests = mockService.getRequestPaths();
747     Assert.assertEquals(1, actualRequests.size());
748 
749     String apiClientHeaderKey =
750         mockService
751             .getRequestHeaders()
752             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
753             .iterator()
754             .next();
755     Assert.assertTrue(
756         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
757             .matcher(apiClientHeaderKey)
758             .matches());
759   }
760 
761   @Test
undeletePrivateCloudExceptionTest2()762   public void undeletePrivateCloudExceptionTest2() throws Exception {
763     ApiException exception =
764         ApiExceptionFactory.createException(
765             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
766     mockService.addException(exception);
767 
768     try {
769       String name = "projects/project-6537/locations/location-6537/privateClouds/privateCloud-6537";
770       client.undeletePrivateCloudAsync(name).get();
771       Assert.fail("No exception raised");
772     } catch (ExecutionException e) {
773     }
774   }
775 
776   @Test
listClustersTest()777   public void listClustersTest() throws Exception {
778     Cluster responsesElement = Cluster.newBuilder().build();
779     ListClustersResponse expectedResponse =
780         ListClustersResponse.newBuilder()
781             .setNextPageToken("")
782             .addAllClusters(Arrays.asList(responsesElement))
783             .build();
784     mockService.addResponse(expectedResponse);
785 
786     PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
787 
788     ListClustersPagedResponse pagedListResponse = client.listClusters(parent);
789 
790     List<Cluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
791 
792     Assert.assertEquals(1, resources.size());
793     Assert.assertEquals(expectedResponse.getClustersList().get(0), resources.get(0));
794 
795     List<String> actualRequests = mockService.getRequestPaths();
796     Assert.assertEquals(1, actualRequests.size());
797 
798     String apiClientHeaderKey =
799         mockService
800             .getRequestHeaders()
801             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
802             .iterator()
803             .next();
804     Assert.assertTrue(
805         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
806             .matcher(apiClientHeaderKey)
807             .matches());
808   }
809 
810   @Test
listClustersExceptionTest()811   public void listClustersExceptionTest() throws Exception {
812     ApiException exception =
813         ApiExceptionFactory.createException(
814             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
815     mockService.addException(exception);
816 
817     try {
818       PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
819       client.listClusters(parent);
820       Assert.fail("No exception raised");
821     } catch (InvalidArgumentException e) {
822       // Expected exception.
823     }
824   }
825 
826   @Test
listClustersTest2()827   public void listClustersTest2() throws Exception {
828     Cluster responsesElement = Cluster.newBuilder().build();
829     ListClustersResponse expectedResponse =
830         ListClustersResponse.newBuilder()
831             .setNextPageToken("")
832             .addAllClusters(Arrays.asList(responsesElement))
833             .build();
834     mockService.addResponse(expectedResponse);
835 
836     String parent = "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
837 
838     ListClustersPagedResponse pagedListResponse = client.listClusters(parent);
839 
840     List<Cluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
841 
842     Assert.assertEquals(1, resources.size());
843     Assert.assertEquals(expectedResponse.getClustersList().get(0), resources.get(0));
844 
845     List<String> actualRequests = mockService.getRequestPaths();
846     Assert.assertEquals(1, actualRequests.size());
847 
848     String apiClientHeaderKey =
849         mockService
850             .getRequestHeaders()
851             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
852             .iterator()
853             .next();
854     Assert.assertTrue(
855         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
856             .matcher(apiClientHeaderKey)
857             .matches());
858   }
859 
860   @Test
listClustersExceptionTest2()861   public void listClustersExceptionTest2() throws Exception {
862     ApiException exception =
863         ApiExceptionFactory.createException(
864             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
865     mockService.addException(exception);
866 
867     try {
868       String parent =
869           "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
870       client.listClusters(parent);
871       Assert.fail("No exception raised");
872     } catch (InvalidArgumentException e) {
873       // Expected exception.
874     }
875   }
876 
877   @Test
getClusterTest()878   public void getClusterTest() throws Exception {
879     Cluster expectedResponse =
880         Cluster.newBuilder()
881             .setName(
882                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
883                     .toString())
884             .setCreateTime(Timestamp.newBuilder().build())
885             .setUpdateTime(Timestamp.newBuilder().build())
886             .setManagement(true)
887             .setUid("uid115792")
888             .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
889             .build();
890     mockService.addResponse(expectedResponse);
891 
892     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]");
893 
894     Cluster actualResponse = client.getCluster(name);
895     Assert.assertEquals(expectedResponse, actualResponse);
896 
897     List<String> actualRequests = mockService.getRequestPaths();
898     Assert.assertEquals(1, actualRequests.size());
899 
900     String apiClientHeaderKey =
901         mockService
902             .getRequestHeaders()
903             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
904             .iterator()
905             .next();
906     Assert.assertTrue(
907         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
908             .matcher(apiClientHeaderKey)
909             .matches());
910   }
911 
912   @Test
getClusterExceptionTest()913   public void getClusterExceptionTest() throws Exception {
914     ApiException exception =
915         ApiExceptionFactory.createException(
916             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
917     mockService.addException(exception);
918 
919     try {
920       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]");
921       client.getCluster(name);
922       Assert.fail("No exception raised");
923     } catch (InvalidArgumentException e) {
924       // Expected exception.
925     }
926   }
927 
928   @Test
getClusterTest2()929   public void getClusterTest2() throws Exception {
930     Cluster expectedResponse =
931         Cluster.newBuilder()
932             .setName(
933                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
934                     .toString())
935             .setCreateTime(Timestamp.newBuilder().build())
936             .setUpdateTime(Timestamp.newBuilder().build())
937             .setManagement(true)
938             .setUid("uid115792")
939             .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
940             .build();
941     mockService.addResponse(expectedResponse);
942 
943     String name =
944         "projects/project-1428/locations/location-1428/privateClouds/privateCloud-1428/clusters/cluster-1428";
945 
946     Cluster actualResponse = client.getCluster(name);
947     Assert.assertEquals(expectedResponse, actualResponse);
948 
949     List<String> actualRequests = mockService.getRequestPaths();
950     Assert.assertEquals(1, actualRequests.size());
951 
952     String apiClientHeaderKey =
953         mockService
954             .getRequestHeaders()
955             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
956             .iterator()
957             .next();
958     Assert.assertTrue(
959         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
960             .matcher(apiClientHeaderKey)
961             .matches());
962   }
963 
964   @Test
getClusterExceptionTest2()965   public void getClusterExceptionTest2() throws Exception {
966     ApiException exception =
967         ApiExceptionFactory.createException(
968             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
969     mockService.addException(exception);
970 
971     try {
972       String name =
973           "projects/project-1428/locations/location-1428/privateClouds/privateCloud-1428/clusters/cluster-1428";
974       client.getCluster(name);
975       Assert.fail("No exception raised");
976     } catch (InvalidArgumentException e) {
977       // Expected exception.
978     }
979   }
980 
981   @Test
createClusterTest()982   public void createClusterTest() throws Exception {
983     Cluster expectedResponse =
984         Cluster.newBuilder()
985             .setName(
986                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
987                     .toString())
988             .setCreateTime(Timestamp.newBuilder().build())
989             .setUpdateTime(Timestamp.newBuilder().build())
990             .setManagement(true)
991             .setUid("uid115792")
992             .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
993             .build();
994     Operation resultOperation =
995         Operation.newBuilder()
996             .setName("createClusterTest")
997             .setDone(true)
998             .setResponse(Any.pack(expectedResponse))
999             .build();
1000     mockService.addResponse(resultOperation);
1001 
1002     PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1003     Cluster cluster = Cluster.newBuilder().build();
1004     String clusterId = "clusterId561939637";
1005 
1006     Cluster actualResponse = client.createClusterAsync(parent, cluster, clusterId).get();
1007     Assert.assertEquals(expectedResponse, actualResponse);
1008 
1009     List<String> actualRequests = mockService.getRequestPaths();
1010     Assert.assertEquals(1, actualRequests.size());
1011 
1012     String apiClientHeaderKey =
1013         mockService
1014             .getRequestHeaders()
1015             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1016             .iterator()
1017             .next();
1018     Assert.assertTrue(
1019         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1020             .matcher(apiClientHeaderKey)
1021             .matches());
1022   }
1023 
1024   @Test
createClusterExceptionTest()1025   public void createClusterExceptionTest() throws Exception {
1026     ApiException exception =
1027         ApiExceptionFactory.createException(
1028             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1029     mockService.addException(exception);
1030 
1031     try {
1032       PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1033       Cluster cluster = Cluster.newBuilder().build();
1034       String clusterId = "clusterId561939637";
1035       client.createClusterAsync(parent, cluster, clusterId).get();
1036       Assert.fail("No exception raised");
1037     } catch (ExecutionException e) {
1038     }
1039   }
1040 
1041   @Test
createClusterTest2()1042   public void createClusterTest2() throws Exception {
1043     Cluster expectedResponse =
1044         Cluster.newBuilder()
1045             .setName(
1046                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
1047                     .toString())
1048             .setCreateTime(Timestamp.newBuilder().build())
1049             .setUpdateTime(Timestamp.newBuilder().build())
1050             .setManagement(true)
1051             .setUid("uid115792")
1052             .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
1053             .build();
1054     Operation resultOperation =
1055         Operation.newBuilder()
1056             .setName("createClusterTest")
1057             .setDone(true)
1058             .setResponse(Any.pack(expectedResponse))
1059             .build();
1060     mockService.addResponse(resultOperation);
1061 
1062     String parent = "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
1063     Cluster cluster = Cluster.newBuilder().build();
1064     String clusterId = "clusterId561939637";
1065 
1066     Cluster actualResponse = client.createClusterAsync(parent, cluster, clusterId).get();
1067     Assert.assertEquals(expectedResponse, actualResponse);
1068 
1069     List<String> actualRequests = mockService.getRequestPaths();
1070     Assert.assertEquals(1, actualRequests.size());
1071 
1072     String apiClientHeaderKey =
1073         mockService
1074             .getRequestHeaders()
1075             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1076             .iterator()
1077             .next();
1078     Assert.assertTrue(
1079         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1080             .matcher(apiClientHeaderKey)
1081             .matches());
1082   }
1083 
1084   @Test
createClusterExceptionTest2()1085   public void createClusterExceptionTest2() throws Exception {
1086     ApiException exception =
1087         ApiExceptionFactory.createException(
1088             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1089     mockService.addException(exception);
1090 
1091     try {
1092       String parent =
1093           "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
1094       Cluster cluster = Cluster.newBuilder().build();
1095       String clusterId = "clusterId561939637";
1096       client.createClusterAsync(parent, cluster, clusterId).get();
1097       Assert.fail("No exception raised");
1098     } catch (ExecutionException e) {
1099     }
1100   }
1101 
1102   @Test
updateClusterTest()1103   public void updateClusterTest() throws Exception {
1104     Cluster expectedResponse =
1105         Cluster.newBuilder()
1106             .setName(
1107                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
1108                     .toString())
1109             .setCreateTime(Timestamp.newBuilder().build())
1110             .setUpdateTime(Timestamp.newBuilder().build())
1111             .setManagement(true)
1112             .setUid("uid115792")
1113             .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
1114             .build();
1115     Operation resultOperation =
1116         Operation.newBuilder()
1117             .setName("updateClusterTest")
1118             .setDone(true)
1119             .setResponse(Any.pack(expectedResponse))
1120             .build();
1121     mockService.addResponse(resultOperation);
1122 
1123     Cluster cluster =
1124         Cluster.newBuilder()
1125             .setName(
1126                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
1127                     .toString())
1128             .setCreateTime(Timestamp.newBuilder().build())
1129             .setUpdateTime(Timestamp.newBuilder().build())
1130             .setManagement(true)
1131             .setUid("uid115792")
1132             .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
1133             .build();
1134     FieldMask updateMask = FieldMask.newBuilder().build();
1135 
1136     Cluster actualResponse = client.updateClusterAsync(cluster, updateMask).get();
1137     Assert.assertEquals(expectedResponse, actualResponse);
1138 
1139     List<String> actualRequests = mockService.getRequestPaths();
1140     Assert.assertEquals(1, actualRequests.size());
1141 
1142     String apiClientHeaderKey =
1143         mockService
1144             .getRequestHeaders()
1145             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1146             .iterator()
1147             .next();
1148     Assert.assertTrue(
1149         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1150             .matcher(apiClientHeaderKey)
1151             .matches());
1152   }
1153 
1154   @Test
updateClusterExceptionTest()1155   public void updateClusterExceptionTest() throws Exception {
1156     ApiException exception =
1157         ApiExceptionFactory.createException(
1158             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1159     mockService.addException(exception);
1160 
1161     try {
1162       Cluster cluster =
1163           Cluster.newBuilder()
1164               .setName(
1165                   ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
1166                       .toString())
1167               .setCreateTime(Timestamp.newBuilder().build())
1168               .setUpdateTime(Timestamp.newBuilder().build())
1169               .setManagement(true)
1170               .setUid("uid115792")
1171               .putAllNodeTypeConfigs(new HashMap<String, NodeTypeConfig>())
1172               .build();
1173       FieldMask updateMask = FieldMask.newBuilder().build();
1174       client.updateClusterAsync(cluster, updateMask).get();
1175       Assert.fail("No exception raised");
1176     } catch (ExecutionException e) {
1177     }
1178   }
1179 
1180   @Test
deleteClusterTest()1181   public void deleteClusterTest() throws Exception {
1182     Empty expectedResponse = Empty.newBuilder().build();
1183     Operation resultOperation =
1184         Operation.newBuilder()
1185             .setName("deleteClusterTest")
1186             .setDone(true)
1187             .setResponse(Any.pack(expectedResponse))
1188             .build();
1189     mockService.addResponse(resultOperation);
1190 
1191     ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]");
1192 
1193     client.deleteClusterAsync(name).get();
1194 
1195     List<String> actualRequests = mockService.getRequestPaths();
1196     Assert.assertEquals(1, actualRequests.size());
1197 
1198     String apiClientHeaderKey =
1199         mockService
1200             .getRequestHeaders()
1201             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1202             .iterator()
1203             .next();
1204     Assert.assertTrue(
1205         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1206             .matcher(apiClientHeaderKey)
1207             .matches());
1208   }
1209 
1210   @Test
deleteClusterExceptionTest()1211   public void deleteClusterExceptionTest() throws Exception {
1212     ApiException exception =
1213         ApiExceptionFactory.createException(
1214             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1215     mockService.addException(exception);
1216 
1217     try {
1218       ClusterName name = ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]");
1219       client.deleteClusterAsync(name).get();
1220       Assert.fail("No exception raised");
1221     } catch (ExecutionException e) {
1222     }
1223   }
1224 
1225   @Test
deleteClusterTest2()1226   public void deleteClusterTest2() throws Exception {
1227     Empty expectedResponse = Empty.newBuilder().build();
1228     Operation resultOperation =
1229         Operation.newBuilder()
1230             .setName("deleteClusterTest")
1231             .setDone(true)
1232             .setResponse(Any.pack(expectedResponse))
1233             .build();
1234     mockService.addResponse(resultOperation);
1235 
1236     String name =
1237         "projects/project-1428/locations/location-1428/privateClouds/privateCloud-1428/clusters/cluster-1428";
1238 
1239     client.deleteClusterAsync(name).get();
1240 
1241     List<String> actualRequests = mockService.getRequestPaths();
1242     Assert.assertEquals(1, actualRequests.size());
1243 
1244     String apiClientHeaderKey =
1245         mockService
1246             .getRequestHeaders()
1247             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1248             .iterator()
1249             .next();
1250     Assert.assertTrue(
1251         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1252             .matcher(apiClientHeaderKey)
1253             .matches());
1254   }
1255 
1256   @Test
deleteClusterExceptionTest2()1257   public void deleteClusterExceptionTest2() throws Exception {
1258     ApiException exception =
1259         ApiExceptionFactory.createException(
1260             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1261     mockService.addException(exception);
1262 
1263     try {
1264       String name =
1265           "projects/project-1428/locations/location-1428/privateClouds/privateCloud-1428/clusters/cluster-1428";
1266       client.deleteClusterAsync(name).get();
1267       Assert.fail("No exception raised");
1268     } catch (ExecutionException e) {
1269     }
1270   }
1271 
1272   @Test
listSubnetsTest()1273   public void listSubnetsTest() throws Exception {
1274     Subnet responsesElement = Subnet.newBuilder().build();
1275     ListSubnetsResponse expectedResponse =
1276         ListSubnetsResponse.newBuilder()
1277             .setNextPageToken("")
1278             .addAllSubnets(Arrays.asList(responsesElement))
1279             .build();
1280     mockService.addResponse(expectedResponse);
1281 
1282     PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1283 
1284     ListSubnetsPagedResponse pagedListResponse = client.listSubnets(parent);
1285 
1286     List<Subnet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1287 
1288     Assert.assertEquals(1, resources.size());
1289     Assert.assertEquals(expectedResponse.getSubnetsList().get(0), resources.get(0));
1290 
1291     List<String> actualRequests = mockService.getRequestPaths();
1292     Assert.assertEquals(1, actualRequests.size());
1293 
1294     String apiClientHeaderKey =
1295         mockService
1296             .getRequestHeaders()
1297             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1298             .iterator()
1299             .next();
1300     Assert.assertTrue(
1301         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1302             .matcher(apiClientHeaderKey)
1303             .matches());
1304   }
1305 
1306   @Test
listSubnetsExceptionTest()1307   public void listSubnetsExceptionTest() throws Exception {
1308     ApiException exception =
1309         ApiExceptionFactory.createException(
1310             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1311     mockService.addException(exception);
1312 
1313     try {
1314       PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1315       client.listSubnets(parent);
1316       Assert.fail("No exception raised");
1317     } catch (InvalidArgumentException e) {
1318       // Expected exception.
1319     }
1320   }
1321 
1322   @Test
listSubnetsTest2()1323   public void listSubnetsTest2() throws Exception {
1324     Subnet responsesElement = Subnet.newBuilder().build();
1325     ListSubnetsResponse expectedResponse =
1326         ListSubnetsResponse.newBuilder()
1327             .setNextPageToken("")
1328             .addAllSubnets(Arrays.asList(responsesElement))
1329             .build();
1330     mockService.addResponse(expectedResponse);
1331 
1332     String parent = "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
1333 
1334     ListSubnetsPagedResponse pagedListResponse = client.listSubnets(parent);
1335 
1336     List<Subnet> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1337 
1338     Assert.assertEquals(1, resources.size());
1339     Assert.assertEquals(expectedResponse.getSubnetsList().get(0), resources.get(0));
1340 
1341     List<String> actualRequests = mockService.getRequestPaths();
1342     Assert.assertEquals(1, actualRequests.size());
1343 
1344     String apiClientHeaderKey =
1345         mockService
1346             .getRequestHeaders()
1347             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1348             .iterator()
1349             .next();
1350     Assert.assertTrue(
1351         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1352             .matcher(apiClientHeaderKey)
1353             .matches());
1354   }
1355 
1356   @Test
listSubnetsExceptionTest2()1357   public void listSubnetsExceptionTest2() throws Exception {
1358     ApiException exception =
1359         ApiExceptionFactory.createException(
1360             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1361     mockService.addException(exception);
1362 
1363     try {
1364       String parent =
1365           "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
1366       client.listSubnets(parent);
1367       Assert.fail("No exception raised");
1368     } catch (InvalidArgumentException e) {
1369       // Expected exception.
1370     }
1371   }
1372 
1373   @Test
listNodeTypesTest()1374   public void listNodeTypesTest() throws Exception {
1375     NodeType responsesElement = NodeType.newBuilder().build();
1376     ListNodeTypesResponse expectedResponse =
1377         ListNodeTypesResponse.newBuilder()
1378             .setNextPageToken("")
1379             .addAllNodeTypes(Arrays.asList(responsesElement))
1380             .build();
1381     mockService.addResponse(expectedResponse);
1382 
1383     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1384 
1385     ListNodeTypesPagedResponse pagedListResponse = client.listNodeTypes(parent);
1386 
1387     List<NodeType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1388 
1389     Assert.assertEquals(1, resources.size());
1390     Assert.assertEquals(expectedResponse.getNodeTypesList().get(0), resources.get(0));
1391 
1392     List<String> actualRequests = mockService.getRequestPaths();
1393     Assert.assertEquals(1, actualRequests.size());
1394 
1395     String apiClientHeaderKey =
1396         mockService
1397             .getRequestHeaders()
1398             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1399             .iterator()
1400             .next();
1401     Assert.assertTrue(
1402         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1403             .matcher(apiClientHeaderKey)
1404             .matches());
1405   }
1406 
1407   @Test
listNodeTypesExceptionTest()1408   public void listNodeTypesExceptionTest() throws Exception {
1409     ApiException exception =
1410         ApiExceptionFactory.createException(
1411             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1412     mockService.addException(exception);
1413 
1414     try {
1415       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
1416       client.listNodeTypes(parent);
1417       Assert.fail("No exception raised");
1418     } catch (InvalidArgumentException e) {
1419       // Expected exception.
1420     }
1421   }
1422 
1423   @Test
listNodeTypesTest2()1424   public void listNodeTypesTest2() throws Exception {
1425     NodeType responsesElement = NodeType.newBuilder().build();
1426     ListNodeTypesResponse expectedResponse =
1427         ListNodeTypesResponse.newBuilder()
1428             .setNextPageToken("")
1429             .addAllNodeTypes(Arrays.asList(responsesElement))
1430             .build();
1431     mockService.addResponse(expectedResponse);
1432 
1433     String parent = "projects/project-5833/locations/location-5833";
1434 
1435     ListNodeTypesPagedResponse pagedListResponse = client.listNodeTypes(parent);
1436 
1437     List<NodeType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1438 
1439     Assert.assertEquals(1, resources.size());
1440     Assert.assertEquals(expectedResponse.getNodeTypesList().get(0), resources.get(0));
1441 
1442     List<String> actualRequests = mockService.getRequestPaths();
1443     Assert.assertEquals(1, actualRequests.size());
1444 
1445     String apiClientHeaderKey =
1446         mockService
1447             .getRequestHeaders()
1448             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1449             .iterator()
1450             .next();
1451     Assert.assertTrue(
1452         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1453             .matcher(apiClientHeaderKey)
1454             .matches());
1455   }
1456 
1457   @Test
listNodeTypesExceptionTest2()1458   public void listNodeTypesExceptionTest2() throws Exception {
1459     ApiException exception =
1460         ApiExceptionFactory.createException(
1461             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1462     mockService.addException(exception);
1463 
1464     try {
1465       String parent = "projects/project-5833/locations/location-5833";
1466       client.listNodeTypes(parent);
1467       Assert.fail("No exception raised");
1468     } catch (InvalidArgumentException e) {
1469       // Expected exception.
1470     }
1471   }
1472 
1473   @Test
getNodeTypeTest()1474   public void getNodeTypeTest() throws Exception {
1475     NodeType expectedResponse =
1476         NodeType.newBuilder()
1477             .setName(NodeTypeName.of("[PROJECT]", "[LOCATION]", "[NODE_TYPE]").toString())
1478             .setNodeTypeId("nodeTypeId1245332119")
1479             .setDisplayName("displayName1714148973")
1480             .setVirtualCpuCount(289038212)
1481             .setTotalCoreCount(-282953654)
1482             .setMemoryGb(1726613721)
1483             .setDiskSizeGb(-757478089)
1484             .addAllAvailableCustomCoreCounts(new ArrayList<Integer>())
1485             .build();
1486     mockService.addResponse(expectedResponse);
1487 
1488     NodeTypeName name = NodeTypeName.of("[PROJECT]", "[LOCATION]", "[NODE_TYPE]");
1489 
1490     NodeType actualResponse = client.getNodeType(name);
1491     Assert.assertEquals(expectedResponse, actualResponse);
1492 
1493     List<String> actualRequests = mockService.getRequestPaths();
1494     Assert.assertEquals(1, actualRequests.size());
1495 
1496     String apiClientHeaderKey =
1497         mockService
1498             .getRequestHeaders()
1499             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1500             .iterator()
1501             .next();
1502     Assert.assertTrue(
1503         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1504             .matcher(apiClientHeaderKey)
1505             .matches());
1506   }
1507 
1508   @Test
getNodeTypeExceptionTest()1509   public void getNodeTypeExceptionTest() throws Exception {
1510     ApiException exception =
1511         ApiExceptionFactory.createException(
1512             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1513     mockService.addException(exception);
1514 
1515     try {
1516       NodeTypeName name = NodeTypeName.of("[PROJECT]", "[LOCATION]", "[NODE_TYPE]");
1517       client.getNodeType(name);
1518       Assert.fail("No exception raised");
1519     } catch (InvalidArgumentException e) {
1520       // Expected exception.
1521     }
1522   }
1523 
1524   @Test
getNodeTypeTest2()1525   public void getNodeTypeTest2() throws Exception {
1526     NodeType expectedResponse =
1527         NodeType.newBuilder()
1528             .setName(NodeTypeName.of("[PROJECT]", "[LOCATION]", "[NODE_TYPE]").toString())
1529             .setNodeTypeId("nodeTypeId1245332119")
1530             .setDisplayName("displayName1714148973")
1531             .setVirtualCpuCount(289038212)
1532             .setTotalCoreCount(-282953654)
1533             .setMemoryGb(1726613721)
1534             .setDiskSizeGb(-757478089)
1535             .addAllAvailableCustomCoreCounts(new ArrayList<Integer>())
1536             .build();
1537     mockService.addResponse(expectedResponse);
1538 
1539     String name = "projects/project-1203/locations/location-1203/nodeTypes/nodeType-1203";
1540 
1541     NodeType actualResponse = client.getNodeType(name);
1542     Assert.assertEquals(expectedResponse, actualResponse);
1543 
1544     List<String> actualRequests = mockService.getRequestPaths();
1545     Assert.assertEquals(1, actualRequests.size());
1546 
1547     String apiClientHeaderKey =
1548         mockService
1549             .getRequestHeaders()
1550             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1551             .iterator()
1552             .next();
1553     Assert.assertTrue(
1554         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1555             .matcher(apiClientHeaderKey)
1556             .matches());
1557   }
1558 
1559   @Test
getNodeTypeExceptionTest2()1560   public void getNodeTypeExceptionTest2() throws Exception {
1561     ApiException exception =
1562         ApiExceptionFactory.createException(
1563             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1564     mockService.addException(exception);
1565 
1566     try {
1567       String name = "projects/project-1203/locations/location-1203/nodeTypes/nodeType-1203";
1568       client.getNodeType(name);
1569       Assert.fail("No exception raised");
1570     } catch (InvalidArgumentException e) {
1571       // Expected exception.
1572     }
1573   }
1574 
1575   @Test
showNsxCredentialsTest()1576   public void showNsxCredentialsTest() throws Exception {
1577     Credentials expectedResponse =
1578         Credentials.newBuilder()
1579             .setUsername("username-265713450")
1580             .setPassword("password1216985755")
1581             .build();
1582     mockService.addResponse(expectedResponse);
1583 
1584     PrivateCloudName privateCloud =
1585         PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1586 
1587     Credentials actualResponse = client.showNsxCredentials(privateCloud);
1588     Assert.assertEquals(expectedResponse, actualResponse);
1589 
1590     List<String> actualRequests = mockService.getRequestPaths();
1591     Assert.assertEquals(1, actualRequests.size());
1592 
1593     String apiClientHeaderKey =
1594         mockService
1595             .getRequestHeaders()
1596             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1597             .iterator()
1598             .next();
1599     Assert.assertTrue(
1600         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1601             .matcher(apiClientHeaderKey)
1602             .matches());
1603   }
1604 
1605   @Test
showNsxCredentialsExceptionTest()1606   public void showNsxCredentialsExceptionTest() throws Exception {
1607     ApiException exception =
1608         ApiExceptionFactory.createException(
1609             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1610     mockService.addException(exception);
1611 
1612     try {
1613       PrivateCloudName privateCloud =
1614           PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1615       client.showNsxCredentials(privateCloud);
1616       Assert.fail("No exception raised");
1617     } catch (InvalidArgumentException e) {
1618       // Expected exception.
1619     }
1620   }
1621 
1622   @Test
showNsxCredentialsTest2()1623   public void showNsxCredentialsTest2() throws Exception {
1624     Credentials expectedResponse =
1625         Credentials.newBuilder()
1626             .setUsername("username-265713450")
1627             .setPassword("password1216985755")
1628             .build();
1629     mockService.addResponse(expectedResponse);
1630 
1631     String privateCloud =
1632         "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1633 
1634     Credentials actualResponse = client.showNsxCredentials(privateCloud);
1635     Assert.assertEquals(expectedResponse, actualResponse);
1636 
1637     List<String> actualRequests = mockService.getRequestPaths();
1638     Assert.assertEquals(1, actualRequests.size());
1639 
1640     String apiClientHeaderKey =
1641         mockService
1642             .getRequestHeaders()
1643             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1644             .iterator()
1645             .next();
1646     Assert.assertTrue(
1647         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1648             .matcher(apiClientHeaderKey)
1649             .matches());
1650   }
1651 
1652   @Test
showNsxCredentialsExceptionTest2()1653   public void showNsxCredentialsExceptionTest2() throws Exception {
1654     ApiException exception =
1655         ApiExceptionFactory.createException(
1656             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1657     mockService.addException(exception);
1658 
1659     try {
1660       String privateCloud =
1661           "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1662       client.showNsxCredentials(privateCloud);
1663       Assert.fail("No exception raised");
1664     } catch (InvalidArgumentException e) {
1665       // Expected exception.
1666     }
1667   }
1668 
1669   @Test
showVcenterCredentialsTest()1670   public void showVcenterCredentialsTest() throws Exception {
1671     Credentials expectedResponse =
1672         Credentials.newBuilder()
1673             .setUsername("username-265713450")
1674             .setPassword("password1216985755")
1675             .build();
1676     mockService.addResponse(expectedResponse);
1677 
1678     PrivateCloudName privateCloud =
1679         PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1680 
1681     Credentials actualResponse = client.showVcenterCredentials(privateCloud);
1682     Assert.assertEquals(expectedResponse, actualResponse);
1683 
1684     List<String> actualRequests = mockService.getRequestPaths();
1685     Assert.assertEquals(1, actualRequests.size());
1686 
1687     String apiClientHeaderKey =
1688         mockService
1689             .getRequestHeaders()
1690             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1691             .iterator()
1692             .next();
1693     Assert.assertTrue(
1694         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1695             .matcher(apiClientHeaderKey)
1696             .matches());
1697   }
1698 
1699   @Test
showVcenterCredentialsExceptionTest()1700   public void showVcenterCredentialsExceptionTest() throws Exception {
1701     ApiException exception =
1702         ApiExceptionFactory.createException(
1703             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1704     mockService.addException(exception);
1705 
1706     try {
1707       PrivateCloudName privateCloud =
1708           PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1709       client.showVcenterCredentials(privateCloud);
1710       Assert.fail("No exception raised");
1711     } catch (InvalidArgumentException e) {
1712       // Expected exception.
1713     }
1714   }
1715 
1716   @Test
showVcenterCredentialsTest2()1717   public void showVcenterCredentialsTest2() throws Exception {
1718     Credentials expectedResponse =
1719         Credentials.newBuilder()
1720             .setUsername("username-265713450")
1721             .setPassword("password1216985755")
1722             .build();
1723     mockService.addResponse(expectedResponse);
1724 
1725     String privateCloud =
1726         "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1727 
1728     Credentials actualResponse = client.showVcenterCredentials(privateCloud);
1729     Assert.assertEquals(expectedResponse, actualResponse);
1730 
1731     List<String> actualRequests = mockService.getRequestPaths();
1732     Assert.assertEquals(1, actualRequests.size());
1733 
1734     String apiClientHeaderKey =
1735         mockService
1736             .getRequestHeaders()
1737             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1738             .iterator()
1739             .next();
1740     Assert.assertTrue(
1741         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1742             .matcher(apiClientHeaderKey)
1743             .matches());
1744   }
1745 
1746   @Test
showVcenterCredentialsExceptionTest2()1747   public void showVcenterCredentialsExceptionTest2() throws Exception {
1748     ApiException exception =
1749         ApiExceptionFactory.createException(
1750             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1751     mockService.addException(exception);
1752 
1753     try {
1754       String privateCloud =
1755           "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1756       client.showVcenterCredentials(privateCloud);
1757       Assert.fail("No exception raised");
1758     } catch (InvalidArgumentException e) {
1759       // Expected exception.
1760     }
1761   }
1762 
1763   @Test
resetNsxCredentialsTest()1764   public void resetNsxCredentialsTest() throws Exception {
1765     PrivateCloud expectedResponse =
1766         PrivateCloud.newBuilder()
1767             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
1768             .setCreateTime(Timestamp.newBuilder().build())
1769             .setUpdateTime(Timestamp.newBuilder().build())
1770             .setDeleteTime(Timestamp.newBuilder().build())
1771             .setExpireTime(Timestamp.newBuilder().build())
1772             .setNetworkConfig(NetworkConfig.newBuilder().build())
1773             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
1774             .setDescription("description-1724546052")
1775             .setHcx(Hcx.newBuilder().build())
1776             .setNsx(Nsx.newBuilder().build())
1777             .setVcenter(Vcenter.newBuilder().build())
1778             .setUid("uid115792")
1779             .build();
1780     Operation resultOperation =
1781         Operation.newBuilder()
1782             .setName("resetNsxCredentialsTest")
1783             .setDone(true)
1784             .setResponse(Any.pack(expectedResponse))
1785             .build();
1786     mockService.addResponse(resultOperation);
1787 
1788     PrivateCloudName privateCloud =
1789         PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1790 
1791     PrivateCloud actualResponse = client.resetNsxCredentialsAsync(privateCloud).get();
1792     Assert.assertEquals(expectedResponse, actualResponse);
1793 
1794     List<String> actualRequests = mockService.getRequestPaths();
1795     Assert.assertEquals(1, actualRequests.size());
1796 
1797     String apiClientHeaderKey =
1798         mockService
1799             .getRequestHeaders()
1800             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1801             .iterator()
1802             .next();
1803     Assert.assertTrue(
1804         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1805             .matcher(apiClientHeaderKey)
1806             .matches());
1807   }
1808 
1809   @Test
resetNsxCredentialsExceptionTest()1810   public void resetNsxCredentialsExceptionTest() throws Exception {
1811     ApiException exception =
1812         ApiExceptionFactory.createException(
1813             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1814     mockService.addException(exception);
1815 
1816     try {
1817       PrivateCloudName privateCloud =
1818           PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1819       client.resetNsxCredentialsAsync(privateCloud).get();
1820       Assert.fail("No exception raised");
1821     } catch (ExecutionException e) {
1822     }
1823   }
1824 
1825   @Test
resetNsxCredentialsTest2()1826   public void resetNsxCredentialsTest2() throws Exception {
1827     PrivateCloud expectedResponse =
1828         PrivateCloud.newBuilder()
1829             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
1830             .setCreateTime(Timestamp.newBuilder().build())
1831             .setUpdateTime(Timestamp.newBuilder().build())
1832             .setDeleteTime(Timestamp.newBuilder().build())
1833             .setExpireTime(Timestamp.newBuilder().build())
1834             .setNetworkConfig(NetworkConfig.newBuilder().build())
1835             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
1836             .setDescription("description-1724546052")
1837             .setHcx(Hcx.newBuilder().build())
1838             .setNsx(Nsx.newBuilder().build())
1839             .setVcenter(Vcenter.newBuilder().build())
1840             .setUid("uid115792")
1841             .build();
1842     Operation resultOperation =
1843         Operation.newBuilder()
1844             .setName("resetNsxCredentialsTest")
1845             .setDone(true)
1846             .setResponse(Any.pack(expectedResponse))
1847             .build();
1848     mockService.addResponse(resultOperation);
1849 
1850     String privateCloud =
1851         "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1852 
1853     PrivateCloud actualResponse = client.resetNsxCredentialsAsync(privateCloud).get();
1854     Assert.assertEquals(expectedResponse, actualResponse);
1855 
1856     List<String> actualRequests = mockService.getRequestPaths();
1857     Assert.assertEquals(1, actualRequests.size());
1858 
1859     String apiClientHeaderKey =
1860         mockService
1861             .getRequestHeaders()
1862             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1863             .iterator()
1864             .next();
1865     Assert.assertTrue(
1866         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1867             .matcher(apiClientHeaderKey)
1868             .matches());
1869   }
1870 
1871   @Test
resetNsxCredentialsExceptionTest2()1872   public void resetNsxCredentialsExceptionTest2() throws Exception {
1873     ApiException exception =
1874         ApiExceptionFactory.createException(
1875             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1876     mockService.addException(exception);
1877 
1878     try {
1879       String privateCloud =
1880           "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1881       client.resetNsxCredentialsAsync(privateCloud).get();
1882       Assert.fail("No exception raised");
1883     } catch (ExecutionException e) {
1884     }
1885   }
1886 
1887   @Test
resetVcenterCredentialsTest()1888   public void resetVcenterCredentialsTest() throws Exception {
1889     PrivateCloud expectedResponse =
1890         PrivateCloud.newBuilder()
1891             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
1892             .setCreateTime(Timestamp.newBuilder().build())
1893             .setUpdateTime(Timestamp.newBuilder().build())
1894             .setDeleteTime(Timestamp.newBuilder().build())
1895             .setExpireTime(Timestamp.newBuilder().build())
1896             .setNetworkConfig(NetworkConfig.newBuilder().build())
1897             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
1898             .setDescription("description-1724546052")
1899             .setHcx(Hcx.newBuilder().build())
1900             .setNsx(Nsx.newBuilder().build())
1901             .setVcenter(Vcenter.newBuilder().build())
1902             .setUid("uid115792")
1903             .build();
1904     Operation resultOperation =
1905         Operation.newBuilder()
1906             .setName("resetVcenterCredentialsTest")
1907             .setDone(true)
1908             .setResponse(Any.pack(expectedResponse))
1909             .build();
1910     mockService.addResponse(resultOperation);
1911 
1912     PrivateCloudName privateCloud =
1913         PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1914 
1915     PrivateCloud actualResponse = client.resetVcenterCredentialsAsync(privateCloud).get();
1916     Assert.assertEquals(expectedResponse, actualResponse);
1917 
1918     List<String> actualRequests = mockService.getRequestPaths();
1919     Assert.assertEquals(1, actualRequests.size());
1920 
1921     String apiClientHeaderKey =
1922         mockService
1923             .getRequestHeaders()
1924             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1925             .iterator()
1926             .next();
1927     Assert.assertTrue(
1928         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1929             .matcher(apiClientHeaderKey)
1930             .matches());
1931   }
1932 
1933   @Test
resetVcenterCredentialsExceptionTest()1934   public void resetVcenterCredentialsExceptionTest() throws Exception {
1935     ApiException exception =
1936         ApiExceptionFactory.createException(
1937             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1938     mockService.addException(exception);
1939 
1940     try {
1941       PrivateCloudName privateCloud =
1942           PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
1943       client.resetVcenterCredentialsAsync(privateCloud).get();
1944       Assert.fail("No exception raised");
1945     } catch (ExecutionException e) {
1946     }
1947   }
1948 
1949   @Test
resetVcenterCredentialsTest2()1950   public void resetVcenterCredentialsTest2() throws Exception {
1951     PrivateCloud expectedResponse =
1952         PrivateCloud.newBuilder()
1953             .setName(PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]").toString())
1954             .setCreateTime(Timestamp.newBuilder().build())
1955             .setUpdateTime(Timestamp.newBuilder().build())
1956             .setDeleteTime(Timestamp.newBuilder().build())
1957             .setExpireTime(Timestamp.newBuilder().build())
1958             .setNetworkConfig(NetworkConfig.newBuilder().build())
1959             .setManagementCluster(PrivateCloud.ManagementCluster.newBuilder().build())
1960             .setDescription("description-1724546052")
1961             .setHcx(Hcx.newBuilder().build())
1962             .setNsx(Nsx.newBuilder().build())
1963             .setVcenter(Vcenter.newBuilder().build())
1964             .setUid("uid115792")
1965             .build();
1966     Operation resultOperation =
1967         Operation.newBuilder()
1968             .setName("resetVcenterCredentialsTest")
1969             .setDone(true)
1970             .setResponse(Any.pack(expectedResponse))
1971             .build();
1972     mockService.addResponse(resultOperation);
1973 
1974     String privateCloud =
1975         "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
1976 
1977     PrivateCloud actualResponse = client.resetVcenterCredentialsAsync(privateCloud).get();
1978     Assert.assertEquals(expectedResponse, actualResponse);
1979 
1980     List<String> actualRequests = mockService.getRequestPaths();
1981     Assert.assertEquals(1, actualRequests.size());
1982 
1983     String apiClientHeaderKey =
1984         mockService
1985             .getRequestHeaders()
1986             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1987             .iterator()
1988             .next();
1989     Assert.assertTrue(
1990         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1991             .matcher(apiClientHeaderKey)
1992             .matches());
1993   }
1994 
1995   @Test
resetVcenterCredentialsExceptionTest2()1996   public void resetVcenterCredentialsExceptionTest2() throws Exception {
1997     ApiException exception =
1998         ApiExceptionFactory.createException(
1999             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2000     mockService.addException(exception);
2001 
2002     try {
2003       String privateCloud =
2004           "projects/project-6942/locations/location-6942/privateClouds/privateCloud-6942";
2005       client.resetVcenterCredentialsAsync(privateCloud).get();
2006       Assert.fail("No exception raised");
2007     } catch (ExecutionException e) {
2008     }
2009   }
2010 
2011   @Test
createHcxActivationKeyTest()2012   public void createHcxActivationKeyTest() throws Exception {
2013     HcxActivationKey expectedResponse =
2014         HcxActivationKey.newBuilder()
2015             .setName(
2016                 HcxActivationKeyName.of(
2017                         "[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[HCX_ACTIVATION_KEY]")
2018                     .toString())
2019             .setCreateTime(Timestamp.newBuilder().build())
2020             .setActivationKey("activationKey1757742441")
2021             .setUid("uid115792")
2022             .build();
2023     Operation resultOperation =
2024         Operation.newBuilder()
2025             .setName("createHcxActivationKeyTest")
2026             .setDone(true)
2027             .setResponse(Any.pack(expectedResponse))
2028             .build();
2029     mockService.addResponse(resultOperation);
2030 
2031     PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
2032     HcxActivationKey hcxActivationKey = HcxActivationKey.newBuilder().build();
2033     String hcxActivationKeyId = "hcxActivationKeyId-645871673";
2034 
2035     HcxActivationKey actualResponse =
2036         client.createHcxActivationKeyAsync(parent, hcxActivationKey, hcxActivationKeyId).get();
2037     Assert.assertEquals(expectedResponse, actualResponse);
2038 
2039     List<String> actualRequests = mockService.getRequestPaths();
2040     Assert.assertEquals(1, actualRequests.size());
2041 
2042     String apiClientHeaderKey =
2043         mockService
2044             .getRequestHeaders()
2045             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2046             .iterator()
2047             .next();
2048     Assert.assertTrue(
2049         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2050             .matcher(apiClientHeaderKey)
2051             .matches());
2052   }
2053 
2054   @Test
createHcxActivationKeyExceptionTest()2055   public void createHcxActivationKeyExceptionTest() throws Exception {
2056     ApiException exception =
2057         ApiExceptionFactory.createException(
2058             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2059     mockService.addException(exception);
2060 
2061     try {
2062       PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
2063       HcxActivationKey hcxActivationKey = HcxActivationKey.newBuilder().build();
2064       String hcxActivationKeyId = "hcxActivationKeyId-645871673";
2065       client.createHcxActivationKeyAsync(parent, hcxActivationKey, hcxActivationKeyId).get();
2066       Assert.fail("No exception raised");
2067     } catch (ExecutionException e) {
2068     }
2069   }
2070 
2071   @Test
createHcxActivationKeyTest2()2072   public void createHcxActivationKeyTest2() throws Exception {
2073     HcxActivationKey expectedResponse =
2074         HcxActivationKey.newBuilder()
2075             .setName(
2076                 HcxActivationKeyName.of(
2077                         "[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[HCX_ACTIVATION_KEY]")
2078                     .toString())
2079             .setCreateTime(Timestamp.newBuilder().build())
2080             .setActivationKey("activationKey1757742441")
2081             .setUid("uid115792")
2082             .build();
2083     Operation resultOperation =
2084         Operation.newBuilder()
2085             .setName("createHcxActivationKeyTest")
2086             .setDone(true)
2087             .setResponse(Any.pack(expectedResponse))
2088             .build();
2089     mockService.addResponse(resultOperation);
2090 
2091     String parent = "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
2092     HcxActivationKey hcxActivationKey = HcxActivationKey.newBuilder().build();
2093     String hcxActivationKeyId = "hcxActivationKeyId-645871673";
2094 
2095     HcxActivationKey actualResponse =
2096         client.createHcxActivationKeyAsync(parent, hcxActivationKey, hcxActivationKeyId).get();
2097     Assert.assertEquals(expectedResponse, actualResponse);
2098 
2099     List<String> actualRequests = mockService.getRequestPaths();
2100     Assert.assertEquals(1, actualRequests.size());
2101 
2102     String apiClientHeaderKey =
2103         mockService
2104             .getRequestHeaders()
2105             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2106             .iterator()
2107             .next();
2108     Assert.assertTrue(
2109         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2110             .matcher(apiClientHeaderKey)
2111             .matches());
2112   }
2113 
2114   @Test
createHcxActivationKeyExceptionTest2()2115   public void createHcxActivationKeyExceptionTest2() throws Exception {
2116     ApiException exception =
2117         ApiExceptionFactory.createException(
2118             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2119     mockService.addException(exception);
2120 
2121     try {
2122       String parent =
2123           "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
2124       HcxActivationKey hcxActivationKey = HcxActivationKey.newBuilder().build();
2125       String hcxActivationKeyId = "hcxActivationKeyId-645871673";
2126       client.createHcxActivationKeyAsync(parent, hcxActivationKey, hcxActivationKeyId).get();
2127       Assert.fail("No exception raised");
2128     } catch (ExecutionException e) {
2129     }
2130   }
2131 
2132   @Test
listHcxActivationKeysTest()2133   public void listHcxActivationKeysTest() throws Exception {
2134     HcxActivationKey responsesElement = HcxActivationKey.newBuilder().build();
2135     ListHcxActivationKeysResponse expectedResponse =
2136         ListHcxActivationKeysResponse.newBuilder()
2137             .setNextPageToken("")
2138             .addAllHcxActivationKeys(Arrays.asList(responsesElement))
2139             .build();
2140     mockService.addResponse(expectedResponse);
2141 
2142     PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
2143 
2144     ListHcxActivationKeysPagedResponse pagedListResponse = client.listHcxActivationKeys(parent);
2145 
2146     List<HcxActivationKey> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2147 
2148     Assert.assertEquals(1, resources.size());
2149     Assert.assertEquals(expectedResponse.getHcxActivationKeysList().get(0), resources.get(0));
2150 
2151     List<String> actualRequests = mockService.getRequestPaths();
2152     Assert.assertEquals(1, actualRequests.size());
2153 
2154     String apiClientHeaderKey =
2155         mockService
2156             .getRequestHeaders()
2157             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2158             .iterator()
2159             .next();
2160     Assert.assertTrue(
2161         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2162             .matcher(apiClientHeaderKey)
2163             .matches());
2164   }
2165 
2166   @Test
listHcxActivationKeysExceptionTest()2167   public void listHcxActivationKeysExceptionTest() throws Exception {
2168     ApiException exception =
2169         ApiExceptionFactory.createException(
2170             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2171     mockService.addException(exception);
2172 
2173     try {
2174       PrivateCloudName parent = PrivateCloudName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]");
2175       client.listHcxActivationKeys(parent);
2176       Assert.fail("No exception raised");
2177     } catch (InvalidArgumentException e) {
2178       // Expected exception.
2179     }
2180   }
2181 
2182   @Test
listHcxActivationKeysTest2()2183   public void listHcxActivationKeysTest2() throws Exception {
2184     HcxActivationKey responsesElement = HcxActivationKey.newBuilder().build();
2185     ListHcxActivationKeysResponse expectedResponse =
2186         ListHcxActivationKeysResponse.newBuilder()
2187             .setNextPageToken("")
2188             .addAllHcxActivationKeys(Arrays.asList(responsesElement))
2189             .build();
2190     mockService.addResponse(expectedResponse);
2191 
2192     String parent = "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
2193 
2194     ListHcxActivationKeysPagedResponse pagedListResponse = client.listHcxActivationKeys(parent);
2195 
2196     List<HcxActivationKey> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2197 
2198     Assert.assertEquals(1, resources.size());
2199     Assert.assertEquals(expectedResponse.getHcxActivationKeysList().get(0), resources.get(0));
2200 
2201     List<String> actualRequests = mockService.getRequestPaths();
2202     Assert.assertEquals(1, actualRequests.size());
2203 
2204     String apiClientHeaderKey =
2205         mockService
2206             .getRequestHeaders()
2207             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2208             .iterator()
2209             .next();
2210     Assert.assertTrue(
2211         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2212             .matcher(apiClientHeaderKey)
2213             .matches());
2214   }
2215 
2216   @Test
listHcxActivationKeysExceptionTest2()2217   public void listHcxActivationKeysExceptionTest2() throws Exception {
2218     ApiException exception =
2219         ApiExceptionFactory.createException(
2220             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2221     mockService.addException(exception);
2222 
2223     try {
2224       String parent =
2225           "projects/project-4854/locations/location-4854/privateClouds/privateCloud-4854";
2226       client.listHcxActivationKeys(parent);
2227       Assert.fail("No exception raised");
2228     } catch (InvalidArgumentException e) {
2229       // Expected exception.
2230     }
2231   }
2232 
2233   @Test
getHcxActivationKeyTest()2234   public void getHcxActivationKeyTest() throws Exception {
2235     HcxActivationKey expectedResponse =
2236         HcxActivationKey.newBuilder()
2237             .setName(
2238                 HcxActivationKeyName.of(
2239                         "[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[HCX_ACTIVATION_KEY]")
2240                     .toString())
2241             .setCreateTime(Timestamp.newBuilder().build())
2242             .setActivationKey("activationKey1757742441")
2243             .setUid("uid115792")
2244             .build();
2245     mockService.addResponse(expectedResponse);
2246 
2247     HcxActivationKeyName name =
2248         HcxActivationKeyName.of(
2249             "[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[HCX_ACTIVATION_KEY]");
2250 
2251     HcxActivationKey actualResponse = client.getHcxActivationKey(name);
2252     Assert.assertEquals(expectedResponse, actualResponse);
2253 
2254     List<String> actualRequests = mockService.getRequestPaths();
2255     Assert.assertEquals(1, actualRequests.size());
2256 
2257     String apiClientHeaderKey =
2258         mockService
2259             .getRequestHeaders()
2260             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2261             .iterator()
2262             .next();
2263     Assert.assertTrue(
2264         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2265             .matcher(apiClientHeaderKey)
2266             .matches());
2267   }
2268 
2269   @Test
getHcxActivationKeyExceptionTest()2270   public void getHcxActivationKeyExceptionTest() throws Exception {
2271     ApiException exception =
2272         ApiExceptionFactory.createException(
2273             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2274     mockService.addException(exception);
2275 
2276     try {
2277       HcxActivationKeyName name =
2278           HcxActivationKeyName.of(
2279               "[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[HCX_ACTIVATION_KEY]");
2280       client.getHcxActivationKey(name);
2281       Assert.fail("No exception raised");
2282     } catch (InvalidArgumentException e) {
2283       // Expected exception.
2284     }
2285   }
2286 
2287   @Test
getHcxActivationKeyTest2()2288   public void getHcxActivationKeyTest2() throws Exception {
2289     HcxActivationKey expectedResponse =
2290         HcxActivationKey.newBuilder()
2291             .setName(
2292                 HcxActivationKeyName.of(
2293                         "[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[HCX_ACTIVATION_KEY]")
2294                     .toString())
2295             .setCreateTime(Timestamp.newBuilder().build())
2296             .setActivationKey("activationKey1757742441")
2297             .setUid("uid115792")
2298             .build();
2299     mockService.addResponse(expectedResponse);
2300 
2301     String name =
2302         "projects/project-3178/locations/location-3178/privateClouds/privateCloud-3178/hcxActivationKeys/hcxActivationKey-3178";
2303 
2304     HcxActivationKey actualResponse = client.getHcxActivationKey(name);
2305     Assert.assertEquals(expectedResponse, actualResponse);
2306 
2307     List<String> actualRequests = mockService.getRequestPaths();
2308     Assert.assertEquals(1, actualRequests.size());
2309 
2310     String apiClientHeaderKey =
2311         mockService
2312             .getRequestHeaders()
2313             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2314             .iterator()
2315             .next();
2316     Assert.assertTrue(
2317         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2318             .matcher(apiClientHeaderKey)
2319             .matches());
2320   }
2321 
2322   @Test
getHcxActivationKeyExceptionTest2()2323   public void getHcxActivationKeyExceptionTest2() throws Exception {
2324     ApiException exception =
2325         ApiExceptionFactory.createException(
2326             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2327     mockService.addException(exception);
2328 
2329     try {
2330       String name =
2331           "projects/project-3178/locations/location-3178/privateClouds/privateCloud-3178/hcxActivationKeys/hcxActivationKey-3178";
2332       client.getHcxActivationKey(name);
2333       Assert.fail("No exception raised");
2334     } catch (InvalidArgumentException e) {
2335       // Expected exception.
2336     }
2337   }
2338 
2339   @Test
getNetworkPolicyTest()2340   public void getNetworkPolicyTest() throws Exception {
2341     NetworkPolicy expectedResponse =
2342         NetworkPolicy.newBuilder()
2343             .setName(NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2344             .setCreateTime(Timestamp.newBuilder().build())
2345             .setUpdateTime(Timestamp.newBuilder().build())
2346             .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2347             .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2348             .setEdgeServicesCidr("edgeServicesCidr846515023")
2349             .setUid("uid115792")
2350             .setVmwareEngineNetwork(
2351                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2352                     .toString())
2353             .setDescription("description-1724546052")
2354             .setVmwareEngineNetworkCanonical(
2355                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2356                     .toString())
2357             .build();
2358     mockService.addResponse(expectedResponse);
2359 
2360     NetworkPolicyName name = NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]");
2361 
2362     NetworkPolicy actualResponse = client.getNetworkPolicy(name);
2363     Assert.assertEquals(expectedResponse, actualResponse);
2364 
2365     List<String> actualRequests = mockService.getRequestPaths();
2366     Assert.assertEquals(1, actualRequests.size());
2367 
2368     String apiClientHeaderKey =
2369         mockService
2370             .getRequestHeaders()
2371             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2372             .iterator()
2373             .next();
2374     Assert.assertTrue(
2375         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2376             .matcher(apiClientHeaderKey)
2377             .matches());
2378   }
2379 
2380   @Test
getNetworkPolicyExceptionTest()2381   public void getNetworkPolicyExceptionTest() throws Exception {
2382     ApiException exception =
2383         ApiExceptionFactory.createException(
2384             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2385     mockService.addException(exception);
2386 
2387     try {
2388       NetworkPolicyName name = NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]");
2389       client.getNetworkPolicy(name);
2390       Assert.fail("No exception raised");
2391     } catch (InvalidArgumentException e) {
2392       // Expected exception.
2393     }
2394   }
2395 
2396   @Test
getNetworkPolicyTest2()2397   public void getNetworkPolicyTest2() throws Exception {
2398     NetworkPolicy expectedResponse =
2399         NetworkPolicy.newBuilder()
2400             .setName(NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2401             .setCreateTime(Timestamp.newBuilder().build())
2402             .setUpdateTime(Timestamp.newBuilder().build())
2403             .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2404             .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2405             .setEdgeServicesCidr("edgeServicesCidr846515023")
2406             .setUid("uid115792")
2407             .setVmwareEngineNetwork(
2408                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2409                     .toString())
2410             .setDescription("description-1724546052")
2411             .setVmwareEngineNetworkCanonical(
2412                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2413                     .toString())
2414             .build();
2415     mockService.addResponse(expectedResponse);
2416 
2417     String name =
2418         "projects/project-6412/locations/location-6412/networkPolicies/networkPolicie-6412";
2419 
2420     NetworkPolicy actualResponse = client.getNetworkPolicy(name);
2421     Assert.assertEquals(expectedResponse, actualResponse);
2422 
2423     List<String> actualRequests = mockService.getRequestPaths();
2424     Assert.assertEquals(1, actualRequests.size());
2425 
2426     String apiClientHeaderKey =
2427         mockService
2428             .getRequestHeaders()
2429             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2430             .iterator()
2431             .next();
2432     Assert.assertTrue(
2433         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2434             .matcher(apiClientHeaderKey)
2435             .matches());
2436   }
2437 
2438   @Test
getNetworkPolicyExceptionTest2()2439   public void getNetworkPolicyExceptionTest2() throws Exception {
2440     ApiException exception =
2441         ApiExceptionFactory.createException(
2442             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2443     mockService.addException(exception);
2444 
2445     try {
2446       String name =
2447           "projects/project-6412/locations/location-6412/networkPolicies/networkPolicie-6412";
2448       client.getNetworkPolicy(name);
2449       Assert.fail("No exception raised");
2450     } catch (InvalidArgumentException e) {
2451       // Expected exception.
2452     }
2453   }
2454 
2455   @Test
listNetworkPoliciesTest()2456   public void listNetworkPoliciesTest() throws Exception {
2457     NetworkPolicy responsesElement = NetworkPolicy.newBuilder().build();
2458     ListNetworkPoliciesResponse expectedResponse =
2459         ListNetworkPoliciesResponse.newBuilder()
2460             .setNextPageToken("")
2461             .addAllNetworkPolicies(Arrays.asList(responsesElement))
2462             .build();
2463     mockService.addResponse(expectedResponse);
2464 
2465     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2466 
2467     ListNetworkPoliciesPagedResponse pagedListResponse = client.listNetworkPolicies(parent);
2468 
2469     List<NetworkPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2470 
2471     Assert.assertEquals(1, resources.size());
2472     Assert.assertEquals(expectedResponse.getNetworkPoliciesList().get(0), resources.get(0));
2473 
2474     List<String> actualRequests = mockService.getRequestPaths();
2475     Assert.assertEquals(1, actualRequests.size());
2476 
2477     String apiClientHeaderKey =
2478         mockService
2479             .getRequestHeaders()
2480             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2481             .iterator()
2482             .next();
2483     Assert.assertTrue(
2484         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2485             .matcher(apiClientHeaderKey)
2486             .matches());
2487   }
2488 
2489   @Test
listNetworkPoliciesExceptionTest()2490   public void listNetworkPoliciesExceptionTest() throws Exception {
2491     ApiException exception =
2492         ApiExceptionFactory.createException(
2493             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2494     mockService.addException(exception);
2495 
2496     try {
2497       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2498       client.listNetworkPolicies(parent);
2499       Assert.fail("No exception raised");
2500     } catch (InvalidArgumentException e) {
2501       // Expected exception.
2502     }
2503   }
2504 
2505   @Test
listNetworkPoliciesTest2()2506   public void listNetworkPoliciesTest2() throws Exception {
2507     NetworkPolicy responsesElement = NetworkPolicy.newBuilder().build();
2508     ListNetworkPoliciesResponse expectedResponse =
2509         ListNetworkPoliciesResponse.newBuilder()
2510             .setNextPageToken("")
2511             .addAllNetworkPolicies(Arrays.asList(responsesElement))
2512             .build();
2513     mockService.addResponse(expectedResponse);
2514 
2515     String parent = "projects/project-5833/locations/location-5833";
2516 
2517     ListNetworkPoliciesPagedResponse pagedListResponse = client.listNetworkPolicies(parent);
2518 
2519     List<NetworkPolicy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2520 
2521     Assert.assertEquals(1, resources.size());
2522     Assert.assertEquals(expectedResponse.getNetworkPoliciesList().get(0), resources.get(0));
2523 
2524     List<String> actualRequests = mockService.getRequestPaths();
2525     Assert.assertEquals(1, actualRequests.size());
2526 
2527     String apiClientHeaderKey =
2528         mockService
2529             .getRequestHeaders()
2530             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2531             .iterator()
2532             .next();
2533     Assert.assertTrue(
2534         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2535             .matcher(apiClientHeaderKey)
2536             .matches());
2537   }
2538 
2539   @Test
listNetworkPoliciesExceptionTest2()2540   public void listNetworkPoliciesExceptionTest2() throws Exception {
2541     ApiException exception =
2542         ApiExceptionFactory.createException(
2543             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2544     mockService.addException(exception);
2545 
2546     try {
2547       String parent = "projects/project-5833/locations/location-5833";
2548       client.listNetworkPolicies(parent);
2549       Assert.fail("No exception raised");
2550     } catch (InvalidArgumentException e) {
2551       // Expected exception.
2552     }
2553   }
2554 
2555   @Test
createNetworkPolicyTest()2556   public void createNetworkPolicyTest() throws Exception {
2557     NetworkPolicy expectedResponse =
2558         NetworkPolicy.newBuilder()
2559             .setName(NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2560             .setCreateTime(Timestamp.newBuilder().build())
2561             .setUpdateTime(Timestamp.newBuilder().build())
2562             .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2563             .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2564             .setEdgeServicesCidr("edgeServicesCidr846515023")
2565             .setUid("uid115792")
2566             .setVmwareEngineNetwork(
2567                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2568                     .toString())
2569             .setDescription("description-1724546052")
2570             .setVmwareEngineNetworkCanonical(
2571                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2572                     .toString())
2573             .build();
2574     Operation resultOperation =
2575         Operation.newBuilder()
2576             .setName("createNetworkPolicyTest")
2577             .setDone(true)
2578             .setResponse(Any.pack(expectedResponse))
2579             .build();
2580     mockService.addResponse(resultOperation);
2581 
2582     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2583     NetworkPolicy networkPolicy = NetworkPolicy.newBuilder().build();
2584     String networkPolicyId = "networkPolicyId-727262661";
2585 
2586     NetworkPolicy actualResponse =
2587         client.createNetworkPolicyAsync(parent, networkPolicy, networkPolicyId).get();
2588     Assert.assertEquals(expectedResponse, actualResponse);
2589 
2590     List<String> actualRequests = mockService.getRequestPaths();
2591     Assert.assertEquals(1, actualRequests.size());
2592 
2593     String apiClientHeaderKey =
2594         mockService
2595             .getRequestHeaders()
2596             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2597             .iterator()
2598             .next();
2599     Assert.assertTrue(
2600         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2601             .matcher(apiClientHeaderKey)
2602             .matches());
2603   }
2604 
2605   @Test
createNetworkPolicyExceptionTest()2606   public void createNetworkPolicyExceptionTest() throws Exception {
2607     ApiException exception =
2608         ApiExceptionFactory.createException(
2609             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2610     mockService.addException(exception);
2611 
2612     try {
2613       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2614       NetworkPolicy networkPolicy = NetworkPolicy.newBuilder().build();
2615       String networkPolicyId = "networkPolicyId-727262661";
2616       client.createNetworkPolicyAsync(parent, networkPolicy, networkPolicyId).get();
2617       Assert.fail("No exception raised");
2618     } catch (ExecutionException e) {
2619     }
2620   }
2621 
2622   @Test
createNetworkPolicyTest2()2623   public void createNetworkPolicyTest2() throws Exception {
2624     NetworkPolicy expectedResponse =
2625         NetworkPolicy.newBuilder()
2626             .setName(NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2627             .setCreateTime(Timestamp.newBuilder().build())
2628             .setUpdateTime(Timestamp.newBuilder().build())
2629             .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2630             .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2631             .setEdgeServicesCidr("edgeServicesCidr846515023")
2632             .setUid("uid115792")
2633             .setVmwareEngineNetwork(
2634                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2635                     .toString())
2636             .setDescription("description-1724546052")
2637             .setVmwareEngineNetworkCanonical(
2638                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2639                     .toString())
2640             .build();
2641     Operation resultOperation =
2642         Operation.newBuilder()
2643             .setName("createNetworkPolicyTest")
2644             .setDone(true)
2645             .setResponse(Any.pack(expectedResponse))
2646             .build();
2647     mockService.addResponse(resultOperation);
2648 
2649     String parent = "projects/project-5833/locations/location-5833";
2650     NetworkPolicy networkPolicy = NetworkPolicy.newBuilder().build();
2651     String networkPolicyId = "networkPolicyId-727262661";
2652 
2653     NetworkPolicy actualResponse =
2654         client.createNetworkPolicyAsync(parent, networkPolicy, networkPolicyId).get();
2655     Assert.assertEquals(expectedResponse, actualResponse);
2656 
2657     List<String> actualRequests = mockService.getRequestPaths();
2658     Assert.assertEquals(1, actualRequests.size());
2659 
2660     String apiClientHeaderKey =
2661         mockService
2662             .getRequestHeaders()
2663             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2664             .iterator()
2665             .next();
2666     Assert.assertTrue(
2667         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2668             .matcher(apiClientHeaderKey)
2669             .matches());
2670   }
2671 
2672   @Test
createNetworkPolicyExceptionTest2()2673   public void createNetworkPolicyExceptionTest2() throws Exception {
2674     ApiException exception =
2675         ApiExceptionFactory.createException(
2676             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2677     mockService.addException(exception);
2678 
2679     try {
2680       String parent = "projects/project-5833/locations/location-5833";
2681       NetworkPolicy networkPolicy = NetworkPolicy.newBuilder().build();
2682       String networkPolicyId = "networkPolicyId-727262661";
2683       client.createNetworkPolicyAsync(parent, networkPolicy, networkPolicyId).get();
2684       Assert.fail("No exception raised");
2685     } catch (ExecutionException e) {
2686     }
2687   }
2688 
2689   @Test
updateNetworkPolicyTest()2690   public void updateNetworkPolicyTest() throws Exception {
2691     NetworkPolicy expectedResponse =
2692         NetworkPolicy.newBuilder()
2693             .setName(NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2694             .setCreateTime(Timestamp.newBuilder().build())
2695             .setUpdateTime(Timestamp.newBuilder().build())
2696             .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2697             .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2698             .setEdgeServicesCidr("edgeServicesCidr846515023")
2699             .setUid("uid115792")
2700             .setVmwareEngineNetwork(
2701                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2702                     .toString())
2703             .setDescription("description-1724546052")
2704             .setVmwareEngineNetworkCanonical(
2705                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2706                     .toString())
2707             .build();
2708     Operation resultOperation =
2709         Operation.newBuilder()
2710             .setName("updateNetworkPolicyTest")
2711             .setDone(true)
2712             .setResponse(Any.pack(expectedResponse))
2713             .build();
2714     mockService.addResponse(resultOperation);
2715 
2716     NetworkPolicy networkPolicy =
2717         NetworkPolicy.newBuilder()
2718             .setName(NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2719             .setCreateTime(Timestamp.newBuilder().build())
2720             .setUpdateTime(Timestamp.newBuilder().build())
2721             .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2722             .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2723             .setEdgeServicesCidr("edgeServicesCidr846515023")
2724             .setUid("uid115792")
2725             .setVmwareEngineNetwork(
2726                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2727                     .toString())
2728             .setDescription("description-1724546052")
2729             .setVmwareEngineNetworkCanonical(
2730                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2731                     .toString())
2732             .build();
2733     FieldMask updateMask = FieldMask.newBuilder().build();
2734 
2735     NetworkPolicy actualResponse = client.updateNetworkPolicyAsync(networkPolicy, updateMask).get();
2736     Assert.assertEquals(expectedResponse, actualResponse);
2737 
2738     List<String> actualRequests = mockService.getRequestPaths();
2739     Assert.assertEquals(1, actualRequests.size());
2740 
2741     String apiClientHeaderKey =
2742         mockService
2743             .getRequestHeaders()
2744             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2745             .iterator()
2746             .next();
2747     Assert.assertTrue(
2748         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2749             .matcher(apiClientHeaderKey)
2750             .matches());
2751   }
2752 
2753   @Test
updateNetworkPolicyExceptionTest()2754   public void updateNetworkPolicyExceptionTest() throws Exception {
2755     ApiException exception =
2756         ApiExceptionFactory.createException(
2757             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2758     mockService.addException(exception);
2759 
2760     try {
2761       NetworkPolicy networkPolicy =
2762           NetworkPolicy.newBuilder()
2763               .setName(
2764                   NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]").toString())
2765               .setCreateTime(Timestamp.newBuilder().build())
2766               .setUpdateTime(Timestamp.newBuilder().build())
2767               .setInternetAccess(NetworkPolicy.NetworkService.newBuilder().build())
2768               .setExternalIp(NetworkPolicy.NetworkService.newBuilder().build())
2769               .setEdgeServicesCidr("edgeServicesCidr846515023")
2770               .setUid("uid115792")
2771               .setVmwareEngineNetwork(
2772                   VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2773                       .toString())
2774               .setDescription("description-1724546052")
2775               .setVmwareEngineNetworkCanonical(
2776                   VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2777                       .toString())
2778               .build();
2779       FieldMask updateMask = FieldMask.newBuilder().build();
2780       client.updateNetworkPolicyAsync(networkPolicy, updateMask).get();
2781       Assert.fail("No exception raised");
2782     } catch (ExecutionException e) {
2783     }
2784   }
2785 
2786   @Test
deleteNetworkPolicyTest()2787   public void deleteNetworkPolicyTest() throws Exception {
2788     Empty expectedResponse = Empty.newBuilder().build();
2789     Operation resultOperation =
2790         Operation.newBuilder()
2791             .setName("deleteNetworkPolicyTest")
2792             .setDone(true)
2793             .setResponse(Any.pack(expectedResponse))
2794             .build();
2795     mockService.addResponse(resultOperation);
2796 
2797     NetworkPolicyName name = NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]");
2798 
2799     client.deleteNetworkPolicyAsync(name).get();
2800 
2801     List<String> actualRequests = mockService.getRequestPaths();
2802     Assert.assertEquals(1, actualRequests.size());
2803 
2804     String apiClientHeaderKey =
2805         mockService
2806             .getRequestHeaders()
2807             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2808             .iterator()
2809             .next();
2810     Assert.assertTrue(
2811         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2812             .matcher(apiClientHeaderKey)
2813             .matches());
2814   }
2815 
2816   @Test
deleteNetworkPolicyExceptionTest()2817   public void deleteNetworkPolicyExceptionTest() throws Exception {
2818     ApiException exception =
2819         ApiExceptionFactory.createException(
2820             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2821     mockService.addException(exception);
2822 
2823     try {
2824       NetworkPolicyName name = NetworkPolicyName.of("[PROJECT]", "[LOCATION]", "[NETWORK_POLICY]");
2825       client.deleteNetworkPolicyAsync(name).get();
2826       Assert.fail("No exception raised");
2827     } catch (ExecutionException e) {
2828     }
2829   }
2830 
2831   @Test
deleteNetworkPolicyTest2()2832   public void deleteNetworkPolicyTest2() throws Exception {
2833     Empty expectedResponse = Empty.newBuilder().build();
2834     Operation resultOperation =
2835         Operation.newBuilder()
2836             .setName("deleteNetworkPolicyTest")
2837             .setDone(true)
2838             .setResponse(Any.pack(expectedResponse))
2839             .build();
2840     mockService.addResponse(resultOperation);
2841 
2842     String name =
2843         "projects/project-6412/locations/location-6412/networkPolicies/networkPolicie-6412";
2844 
2845     client.deleteNetworkPolicyAsync(name).get();
2846 
2847     List<String> actualRequests = mockService.getRequestPaths();
2848     Assert.assertEquals(1, actualRequests.size());
2849 
2850     String apiClientHeaderKey =
2851         mockService
2852             .getRequestHeaders()
2853             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2854             .iterator()
2855             .next();
2856     Assert.assertTrue(
2857         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2858             .matcher(apiClientHeaderKey)
2859             .matches());
2860   }
2861 
2862   @Test
deleteNetworkPolicyExceptionTest2()2863   public void deleteNetworkPolicyExceptionTest2() throws Exception {
2864     ApiException exception =
2865         ApiExceptionFactory.createException(
2866             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2867     mockService.addException(exception);
2868 
2869     try {
2870       String name =
2871           "projects/project-6412/locations/location-6412/networkPolicies/networkPolicie-6412";
2872       client.deleteNetworkPolicyAsync(name).get();
2873       Assert.fail("No exception raised");
2874     } catch (ExecutionException e) {
2875     }
2876   }
2877 
2878   @Test
createVmwareEngineNetworkTest()2879   public void createVmwareEngineNetworkTest() throws Exception {
2880     VmwareEngineNetwork expectedResponse =
2881         VmwareEngineNetwork.newBuilder()
2882             .setName(
2883                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2884                     .toString())
2885             .setCreateTime(Timestamp.newBuilder().build())
2886             .setUpdateTime(Timestamp.newBuilder().build())
2887             .setDescription("description-1724546052")
2888             .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
2889             .setUid("uid115792")
2890             .setEtag("etag3123477")
2891             .build();
2892     Operation resultOperation =
2893         Operation.newBuilder()
2894             .setName("createVmwareEngineNetworkTest")
2895             .setDone(true)
2896             .setResponse(Any.pack(expectedResponse))
2897             .build();
2898     mockService.addResponse(resultOperation);
2899 
2900     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2901     VmwareEngineNetwork vmwareEngineNetwork = VmwareEngineNetwork.newBuilder().build();
2902     String vmwareEngineNetworkId = "vmwareEngineNetworkId532532083";
2903 
2904     VmwareEngineNetwork actualResponse =
2905         client
2906             .createVmwareEngineNetworkAsync(parent, vmwareEngineNetwork, vmwareEngineNetworkId)
2907             .get();
2908     Assert.assertEquals(expectedResponse, actualResponse);
2909 
2910     List<String> actualRequests = mockService.getRequestPaths();
2911     Assert.assertEquals(1, actualRequests.size());
2912 
2913     String apiClientHeaderKey =
2914         mockService
2915             .getRequestHeaders()
2916             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2917             .iterator()
2918             .next();
2919     Assert.assertTrue(
2920         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2921             .matcher(apiClientHeaderKey)
2922             .matches());
2923   }
2924 
2925   @Test
createVmwareEngineNetworkExceptionTest()2926   public void createVmwareEngineNetworkExceptionTest() throws Exception {
2927     ApiException exception =
2928         ApiExceptionFactory.createException(
2929             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2930     mockService.addException(exception);
2931 
2932     try {
2933       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
2934       VmwareEngineNetwork vmwareEngineNetwork = VmwareEngineNetwork.newBuilder().build();
2935       String vmwareEngineNetworkId = "vmwareEngineNetworkId532532083";
2936       client
2937           .createVmwareEngineNetworkAsync(parent, vmwareEngineNetwork, vmwareEngineNetworkId)
2938           .get();
2939       Assert.fail("No exception raised");
2940     } catch (ExecutionException e) {
2941     }
2942   }
2943 
2944   @Test
createVmwareEngineNetworkTest2()2945   public void createVmwareEngineNetworkTest2() throws Exception {
2946     VmwareEngineNetwork expectedResponse =
2947         VmwareEngineNetwork.newBuilder()
2948             .setName(
2949                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
2950                     .toString())
2951             .setCreateTime(Timestamp.newBuilder().build())
2952             .setUpdateTime(Timestamp.newBuilder().build())
2953             .setDescription("description-1724546052")
2954             .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
2955             .setUid("uid115792")
2956             .setEtag("etag3123477")
2957             .build();
2958     Operation resultOperation =
2959         Operation.newBuilder()
2960             .setName("createVmwareEngineNetworkTest")
2961             .setDone(true)
2962             .setResponse(Any.pack(expectedResponse))
2963             .build();
2964     mockService.addResponse(resultOperation);
2965 
2966     String parent = "projects/project-5833/locations/location-5833";
2967     VmwareEngineNetwork vmwareEngineNetwork = VmwareEngineNetwork.newBuilder().build();
2968     String vmwareEngineNetworkId = "vmwareEngineNetworkId532532083";
2969 
2970     VmwareEngineNetwork actualResponse =
2971         client
2972             .createVmwareEngineNetworkAsync(parent, vmwareEngineNetwork, vmwareEngineNetworkId)
2973             .get();
2974     Assert.assertEquals(expectedResponse, actualResponse);
2975 
2976     List<String> actualRequests = mockService.getRequestPaths();
2977     Assert.assertEquals(1, actualRequests.size());
2978 
2979     String apiClientHeaderKey =
2980         mockService
2981             .getRequestHeaders()
2982             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2983             .iterator()
2984             .next();
2985     Assert.assertTrue(
2986         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2987             .matcher(apiClientHeaderKey)
2988             .matches());
2989   }
2990 
2991   @Test
createVmwareEngineNetworkExceptionTest2()2992   public void createVmwareEngineNetworkExceptionTest2() throws Exception {
2993     ApiException exception =
2994         ApiExceptionFactory.createException(
2995             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2996     mockService.addException(exception);
2997 
2998     try {
2999       String parent = "projects/project-5833/locations/location-5833";
3000       VmwareEngineNetwork vmwareEngineNetwork = VmwareEngineNetwork.newBuilder().build();
3001       String vmwareEngineNetworkId = "vmwareEngineNetworkId532532083";
3002       client
3003           .createVmwareEngineNetworkAsync(parent, vmwareEngineNetwork, vmwareEngineNetworkId)
3004           .get();
3005       Assert.fail("No exception raised");
3006     } catch (ExecutionException e) {
3007     }
3008   }
3009 
3010   @Test
updateVmwareEngineNetworkTest()3011   public void updateVmwareEngineNetworkTest() throws Exception {
3012     VmwareEngineNetwork expectedResponse =
3013         VmwareEngineNetwork.newBuilder()
3014             .setName(
3015                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
3016                     .toString())
3017             .setCreateTime(Timestamp.newBuilder().build())
3018             .setUpdateTime(Timestamp.newBuilder().build())
3019             .setDescription("description-1724546052")
3020             .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
3021             .setUid("uid115792")
3022             .setEtag("etag3123477")
3023             .build();
3024     Operation resultOperation =
3025         Operation.newBuilder()
3026             .setName("updateVmwareEngineNetworkTest")
3027             .setDone(true)
3028             .setResponse(Any.pack(expectedResponse))
3029             .build();
3030     mockService.addResponse(resultOperation);
3031 
3032     VmwareEngineNetwork vmwareEngineNetwork =
3033         VmwareEngineNetwork.newBuilder()
3034             .setName(
3035                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
3036                     .toString())
3037             .setCreateTime(Timestamp.newBuilder().build())
3038             .setUpdateTime(Timestamp.newBuilder().build())
3039             .setDescription("description-1724546052")
3040             .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
3041             .setUid("uid115792")
3042             .setEtag("etag3123477")
3043             .build();
3044     FieldMask updateMask = FieldMask.newBuilder().build();
3045 
3046     VmwareEngineNetwork actualResponse =
3047         client.updateVmwareEngineNetworkAsync(vmwareEngineNetwork, updateMask).get();
3048     Assert.assertEquals(expectedResponse, actualResponse);
3049 
3050     List<String> actualRequests = mockService.getRequestPaths();
3051     Assert.assertEquals(1, actualRequests.size());
3052 
3053     String apiClientHeaderKey =
3054         mockService
3055             .getRequestHeaders()
3056             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3057             .iterator()
3058             .next();
3059     Assert.assertTrue(
3060         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3061             .matcher(apiClientHeaderKey)
3062             .matches());
3063   }
3064 
3065   @Test
updateVmwareEngineNetworkExceptionTest()3066   public void updateVmwareEngineNetworkExceptionTest() throws Exception {
3067     ApiException exception =
3068         ApiExceptionFactory.createException(
3069             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3070     mockService.addException(exception);
3071 
3072     try {
3073       VmwareEngineNetwork vmwareEngineNetwork =
3074           VmwareEngineNetwork.newBuilder()
3075               .setName(
3076                   VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
3077                       .toString())
3078               .setCreateTime(Timestamp.newBuilder().build())
3079               .setUpdateTime(Timestamp.newBuilder().build())
3080               .setDescription("description-1724546052")
3081               .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
3082               .setUid("uid115792")
3083               .setEtag("etag3123477")
3084               .build();
3085       FieldMask updateMask = FieldMask.newBuilder().build();
3086       client.updateVmwareEngineNetworkAsync(vmwareEngineNetwork, updateMask).get();
3087       Assert.fail("No exception raised");
3088     } catch (ExecutionException e) {
3089     }
3090   }
3091 
3092   @Test
deleteVmwareEngineNetworkTest()3093   public void deleteVmwareEngineNetworkTest() throws Exception {
3094     Empty expectedResponse = Empty.newBuilder().build();
3095     Operation resultOperation =
3096         Operation.newBuilder()
3097             .setName("deleteVmwareEngineNetworkTest")
3098             .setDone(true)
3099             .setResponse(Any.pack(expectedResponse))
3100             .build();
3101     mockService.addResponse(resultOperation);
3102 
3103     VmwareEngineNetworkName name =
3104         VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]");
3105 
3106     client.deleteVmwareEngineNetworkAsync(name).get();
3107 
3108     List<String> actualRequests = mockService.getRequestPaths();
3109     Assert.assertEquals(1, actualRequests.size());
3110 
3111     String apiClientHeaderKey =
3112         mockService
3113             .getRequestHeaders()
3114             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3115             .iterator()
3116             .next();
3117     Assert.assertTrue(
3118         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3119             .matcher(apiClientHeaderKey)
3120             .matches());
3121   }
3122 
3123   @Test
deleteVmwareEngineNetworkExceptionTest()3124   public void deleteVmwareEngineNetworkExceptionTest() throws Exception {
3125     ApiException exception =
3126         ApiExceptionFactory.createException(
3127             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3128     mockService.addException(exception);
3129 
3130     try {
3131       VmwareEngineNetworkName name =
3132           VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]");
3133       client.deleteVmwareEngineNetworkAsync(name).get();
3134       Assert.fail("No exception raised");
3135     } catch (ExecutionException e) {
3136     }
3137   }
3138 
3139   @Test
deleteVmwareEngineNetworkTest2()3140   public void deleteVmwareEngineNetworkTest2() throws Exception {
3141     Empty expectedResponse = Empty.newBuilder().build();
3142     Operation resultOperation =
3143         Operation.newBuilder()
3144             .setName("deleteVmwareEngineNetworkTest")
3145             .setDone(true)
3146             .setResponse(Any.pack(expectedResponse))
3147             .build();
3148     mockService.addResponse(resultOperation);
3149 
3150     String name =
3151         "projects/project-9883/locations/location-9883/vmwareEngineNetworks/vmwareEngineNetwork-9883";
3152 
3153     client.deleteVmwareEngineNetworkAsync(name).get();
3154 
3155     List<String> actualRequests = mockService.getRequestPaths();
3156     Assert.assertEquals(1, actualRequests.size());
3157 
3158     String apiClientHeaderKey =
3159         mockService
3160             .getRequestHeaders()
3161             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3162             .iterator()
3163             .next();
3164     Assert.assertTrue(
3165         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3166             .matcher(apiClientHeaderKey)
3167             .matches());
3168   }
3169 
3170   @Test
deleteVmwareEngineNetworkExceptionTest2()3171   public void deleteVmwareEngineNetworkExceptionTest2() throws Exception {
3172     ApiException exception =
3173         ApiExceptionFactory.createException(
3174             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3175     mockService.addException(exception);
3176 
3177     try {
3178       String name =
3179           "projects/project-9883/locations/location-9883/vmwareEngineNetworks/vmwareEngineNetwork-9883";
3180       client.deleteVmwareEngineNetworkAsync(name).get();
3181       Assert.fail("No exception raised");
3182     } catch (ExecutionException e) {
3183     }
3184   }
3185 
3186   @Test
getVmwareEngineNetworkTest()3187   public void getVmwareEngineNetworkTest() throws Exception {
3188     VmwareEngineNetwork expectedResponse =
3189         VmwareEngineNetwork.newBuilder()
3190             .setName(
3191                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
3192                     .toString())
3193             .setCreateTime(Timestamp.newBuilder().build())
3194             .setUpdateTime(Timestamp.newBuilder().build())
3195             .setDescription("description-1724546052")
3196             .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
3197             .setUid("uid115792")
3198             .setEtag("etag3123477")
3199             .build();
3200     mockService.addResponse(expectedResponse);
3201 
3202     VmwareEngineNetworkName name =
3203         VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]");
3204 
3205     VmwareEngineNetwork actualResponse = client.getVmwareEngineNetwork(name);
3206     Assert.assertEquals(expectedResponse, actualResponse);
3207 
3208     List<String> actualRequests = mockService.getRequestPaths();
3209     Assert.assertEquals(1, actualRequests.size());
3210 
3211     String apiClientHeaderKey =
3212         mockService
3213             .getRequestHeaders()
3214             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3215             .iterator()
3216             .next();
3217     Assert.assertTrue(
3218         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3219             .matcher(apiClientHeaderKey)
3220             .matches());
3221   }
3222 
3223   @Test
getVmwareEngineNetworkExceptionTest()3224   public void getVmwareEngineNetworkExceptionTest() throws Exception {
3225     ApiException exception =
3226         ApiExceptionFactory.createException(
3227             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3228     mockService.addException(exception);
3229 
3230     try {
3231       VmwareEngineNetworkName name =
3232           VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]");
3233       client.getVmwareEngineNetwork(name);
3234       Assert.fail("No exception raised");
3235     } catch (InvalidArgumentException e) {
3236       // Expected exception.
3237     }
3238   }
3239 
3240   @Test
getVmwareEngineNetworkTest2()3241   public void getVmwareEngineNetworkTest2() throws Exception {
3242     VmwareEngineNetwork expectedResponse =
3243         VmwareEngineNetwork.newBuilder()
3244             .setName(
3245                 VmwareEngineNetworkName.of("[PROJECT]", "[LOCATION]", "[VMWARE_ENGINE_NETWORK]")
3246                     .toString())
3247             .setCreateTime(Timestamp.newBuilder().build())
3248             .setUpdateTime(Timestamp.newBuilder().build())
3249             .setDescription("description-1724546052")
3250             .addAllVpcNetworks(new ArrayList<VmwareEngineNetwork.VpcNetwork>())
3251             .setUid("uid115792")
3252             .setEtag("etag3123477")
3253             .build();
3254     mockService.addResponse(expectedResponse);
3255 
3256     String name =
3257         "projects/project-9883/locations/location-9883/vmwareEngineNetworks/vmwareEngineNetwork-9883";
3258 
3259     VmwareEngineNetwork actualResponse = client.getVmwareEngineNetwork(name);
3260     Assert.assertEquals(expectedResponse, actualResponse);
3261 
3262     List<String> actualRequests = mockService.getRequestPaths();
3263     Assert.assertEquals(1, actualRequests.size());
3264 
3265     String apiClientHeaderKey =
3266         mockService
3267             .getRequestHeaders()
3268             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3269             .iterator()
3270             .next();
3271     Assert.assertTrue(
3272         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3273             .matcher(apiClientHeaderKey)
3274             .matches());
3275   }
3276 
3277   @Test
getVmwareEngineNetworkExceptionTest2()3278   public void getVmwareEngineNetworkExceptionTest2() throws Exception {
3279     ApiException exception =
3280         ApiExceptionFactory.createException(
3281             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3282     mockService.addException(exception);
3283 
3284     try {
3285       String name =
3286           "projects/project-9883/locations/location-9883/vmwareEngineNetworks/vmwareEngineNetwork-9883";
3287       client.getVmwareEngineNetwork(name);
3288       Assert.fail("No exception raised");
3289     } catch (InvalidArgumentException e) {
3290       // Expected exception.
3291     }
3292   }
3293 
3294   @Test
listVmwareEngineNetworksTest()3295   public void listVmwareEngineNetworksTest() throws Exception {
3296     VmwareEngineNetwork responsesElement = VmwareEngineNetwork.newBuilder().build();
3297     ListVmwareEngineNetworksResponse expectedResponse =
3298         ListVmwareEngineNetworksResponse.newBuilder()
3299             .setNextPageToken("")
3300             .addAllVmwareEngineNetworks(Arrays.asList(responsesElement))
3301             .build();
3302     mockService.addResponse(expectedResponse);
3303 
3304     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3305 
3306     ListVmwareEngineNetworksPagedResponse pagedListResponse =
3307         client.listVmwareEngineNetworks(parent);
3308 
3309     List<VmwareEngineNetwork> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3310 
3311     Assert.assertEquals(1, resources.size());
3312     Assert.assertEquals(expectedResponse.getVmwareEngineNetworksList().get(0), resources.get(0));
3313 
3314     List<String> actualRequests = mockService.getRequestPaths();
3315     Assert.assertEquals(1, actualRequests.size());
3316 
3317     String apiClientHeaderKey =
3318         mockService
3319             .getRequestHeaders()
3320             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3321             .iterator()
3322             .next();
3323     Assert.assertTrue(
3324         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3325             .matcher(apiClientHeaderKey)
3326             .matches());
3327   }
3328 
3329   @Test
listVmwareEngineNetworksExceptionTest()3330   public void listVmwareEngineNetworksExceptionTest() throws Exception {
3331     ApiException exception =
3332         ApiExceptionFactory.createException(
3333             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3334     mockService.addException(exception);
3335 
3336     try {
3337       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
3338       client.listVmwareEngineNetworks(parent);
3339       Assert.fail("No exception raised");
3340     } catch (InvalidArgumentException e) {
3341       // Expected exception.
3342     }
3343   }
3344 
3345   @Test
listVmwareEngineNetworksTest2()3346   public void listVmwareEngineNetworksTest2() throws Exception {
3347     VmwareEngineNetwork responsesElement = VmwareEngineNetwork.newBuilder().build();
3348     ListVmwareEngineNetworksResponse expectedResponse =
3349         ListVmwareEngineNetworksResponse.newBuilder()
3350             .setNextPageToken("")
3351             .addAllVmwareEngineNetworks(Arrays.asList(responsesElement))
3352             .build();
3353     mockService.addResponse(expectedResponse);
3354 
3355     String parent = "projects/project-5833/locations/location-5833";
3356 
3357     ListVmwareEngineNetworksPagedResponse pagedListResponse =
3358         client.listVmwareEngineNetworks(parent);
3359 
3360     List<VmwareEngineNetwork> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3361 
3362     Assert.assertEquals(1, resources.size());
3363     Assert.assertEquals(expectedResponse.getVmwareEngineNetworksList().get(0), resources.get(0));
3364 
3365     List<String> actualRequests = mockService.getRequestPaths();
3366     Assert.assertEquals(1, actualRequests.size());
3367 
3368     String apiClientHeaderKey =
3369         mockService
3370             .getRequestHeaders()
3371             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3372             .iterator()
3373             .next();
3374     Assert.assertTrue(
3375         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3376             .matcher(apiClientHeaderKey)
3377             .matches());
3378   }
3379 
3380   @Test
listVmwareEngineNetworksExceptionTest2()3381   public void listVmwareEngineNetworksExceptionTest2() throws Exception {
3382     ApiException exception =
3383         ApiExceptionFactory.createException(
3384             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3385     mockService.addException(exception);
3386 
3387     try {
3388       String parent = "projects/project-5833/locations/location-5833";
3389       client.listVmwareEngineNetworks(parent);
3390       Assert.fail("No exception raised");
3391     } catch (InvalidArgumentException e) {
3392       // Expected exception.
3393     }
3394   }
3395 
3396   @Test
listLocationsTest()3397   public void listLocationsTest() throws Exception {
3398     Location responsesElement = Location.newBuilder().build();
3399     ListLocationsResponse expectedResponse =
3400         ListLocationsResponse.newBuilder()
3401             .setNextPageToken("")
3402             .addAllLocations(Arrays.asList(responsesElement))
3403             .build();
3404     mockService.addResponse(expectedResponse);
3405 
3406     ListLocationsRequest request =
3407         ListLocationsRequest.newBuilder()
3408             .setName("projects/project-3664")
3409             .setFilter("filter-1274492040")
3410             .setPageSize(883849137)
3411             .setPageToken("pageToken873572522")
3412             .build();
3413 
3414     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
3415 
3416     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
3417 
3418     Assert.assertEquals(1, resources.size());
3419     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
3420 
3421     List<String> actualRequests = mockService.getRequestPaths();
3422     Assert.assertEquals(1, actualRequests.size());
3423 
3424     String apiClientHeaderKey =
3425         mockService
3426             .getRequestHeaders()
3427             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3428             .iterator()
3429             .next();
3430     Assert.assertTrue(
3431         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3432             .matcher(apiClientHeaderKey)
3433             .matches());
3434   }
3435 
3436   @Test
listLocationsExceptionTest()3437   public void listLocationsExceptionTest() throws Exception {
3438     ApiException exception =
3439         ApiExceptionFactory.createException(
3440             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3441     mockService.addException(exception);
3442 
3443     try {
3444       ListLocationsRequest request =
3445           ListLocationsRequest.newBuilder()
3446               .setName("projects/project-3664")
3447               .setFilter("filter-1274492040")
3448               .setPageSize(883849137)
3449               .setPageToken("pageToken873572522")
3450               .build();
3451       client.listLocations(request);
3452       Assert.fail("No exception raised");
3453     } catch (InvalidArgumentException e) {
3454       // Expected exception.
3455     }
3456   }
3457 
3458   @Test
getLocationTest()3459   public void getLocationTest() throws Exception {
3460     Location expectedResponse =
3461         Location.newBuilder()
3462             .setName("name3373707")
3463             .setLocationId("locationId1541836720")
3464             .setDisplayName("displayName1714148973")
3465             .putAllLabels(new HashMap<String, String>())
3466             .setMetadata(Any.newBuilder().build())
3467             .build();
3468     mockService.addResponse(expectedResponse);
3469 
3470     GetLocationRequest request =
3471         GetLocationRequest.newBuilder()
3472             .setName("projects/project-9062/locations/location-9062")
3473             .build();
3474 
3475     Location actualResponse = client.getLocation(request);
3476     Assert.assertEquals(expectedResponse, actualResponse);
3477 
3478     List<String> actualRequests = mockService.getRequestPaths();
3479     Assert.assertEquals(1, actualRequests.size());
3480 
3481     String apiClientHeaderKey =
3482         mockService
3483             .getRequestHeaders()
3484             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3485             .iterator()
3486             .next();
3487     Assert.assertTrue(
3488         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3489             .matcher(apiClientHeaderKey)
3490             .matches());
3491   }
3492 
3493   @Test
getLocationExceptionTest()3494   public void getLocationExceptionTest() throws Exception {
3495     ApiException exception =
3496         ApiExceptionFactory.createException(
3497             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3498     mockService.addException(exception);
3499 
3500     try {
3501       GetLocationRequest request =
3502           GetLocationRequest.newBuilder()
3503               .setName("projects/project-9062/locations/location-9062")
3504               .build();
3505       client.getLocation(request);
3506       Assert.fail("No exception raised");
3507     } catch (InvalidArgumentException e) {
3508       // Expected exception.
3509     }
3510   }
3511 
3512   @Test
setIamPolicyTest()3513   public void setIamPolicyTest() throws Exception {
3514     Policy expectedResponse =
3515         Policy.newBuilder()
3516             .setVersion(351608024)
3517             .addAllBindings(new ArrayList<Binding>())
3518             .addAllAuditConfigs(new ArrayList<AuditConfig>())
3519             .setEtag(ByteString.EMPTY)
3520             .build();
3521     mockService.addResponse(expectedResponse);
3522 
3523     SetIamPolicyRequest request =
3524         SetIamPolicyRequest.newBuilder()
3525             .setResource(
3526                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
3527                     .toString())
3528             .setPolicy(Policy.newBuilder().build())
3529             .setUpdateMask(FieldMask.newBuilder().build())
3530             .build();
3531 
3532     Policy actualResponse = client.setIamPolicy(request);
3533     Assert.assertEquals(expectedResponse, actualResponse);
3534 
3535     List<String> actualRequests = mockService.getRequestPaths();
3536     Assert.assertEquals(1, actualRequests.size());
3537 
3538     String apiClientHeaderKey =
3539         mockService
3540             .getRequestHeaders()
3541             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3542             .iterator()
3543             .next();
3544     Assert.assertTrue(
3545         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3546             .matcher(apiClientHeaderKey)
3547             .matches());
3548   }
3549 
3550   @Test
setIamPolicyExceptionTest()3551   public void setIamPolicyExceptionTest() throws Exception {
3552     ApiException exception =
3553         ApiExceptionFactory.createException(
3554             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3555     mockService.addException(exception);
3556 
3557     try {
3558       SetIamPolicyRequest request =
3559           SetIamPolicyRequest.newBuilder()
3560               .setResource(
3561                   ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
3562                       .toString())
3563               .setPolicy(Policy.newBuilder().build())
3564               .setUpdateMask(FieldMask.newBuilder().build())
3565               .build();
3566       client.setIamPolicy(request);
3567       Assert.fail("No exception raised");
3568     } catch (InvalidArgumentException e) {
3569       // Expected exception.
3570     }
3571   }
3572 
3573   @Test
getIamPolicyTest()3574   public void getIamPolicyTest() throws Exception {
3575     Policy expectedResponse =
3576         Policy.newBuilder()
3577             .setVersion(351608024)
3578             .addAllBindings(new ArrayList<Binding>())
3579             .addAllAuditConfigs(new ArrayList<AuditConfig>())
3580             .setEtag(ByteString.EMPTY)
3581             .build();
3582     mockService.addResponse(expectedResponse);
3583 
3584     GetIamPolicyRequest request =
3585         GetIamPolicyRequest.newBuilder()
3586             .setResource(
3587                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
3588                     .toString())
3589             .setOptions(GetPolicyOptions.newBuilder().build())
3590             .build();
3591 
3592     Policy actualResponse = client.getIamPolicy(request);
3593     Assert.assertEquals(expectedResponse, actualResponse);
3594 
3595     List<String> actualRequests = mockService.getRequestPaths();
3596     Assert.assertEquals(1, actualRequests.size());
3597 
3598     String apiClientHeaderKey =
3599         mockService
3600             .getRequestHeaders()
3601             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3602             .iterator()
3603             .next();
3604     Assert.assertTrue(
3605         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3606             .matcher(apiClientHeaderKey)
3607             .matches());
3608   }
3609 
3610   @Test
getIamPolicyExceptionTest()3611   public void getIamPolicyExceptionTest() throws Exception {
3612     ApiException exception =
3613         ApiExceptionFactory.createException(
3614             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3615     mockService.addException(exception);
3616 
3617     try {
3618       GetIamPolicyRequest request =
3619           GetIamPolicyRequest.newBuilder()
3620               .setResource(
3621                   ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
3622                       .toString())
3623               .setOptions(GetPolicyOptions.newBuilder().build())
3624               .build();
3625       client.getIamPolicy(request);
3626       Assert.fail("No exception raised");
3627     } catch (InvalidArgumentException e) {
3628       // Expected exception.
3629     }
3630   }
3631 
3632   @Test
testIamPermissionsTest()3633   public void testIamPermissionsTest() throws Exception {
3634     TestIamPermissionsResponse expectedResponse =
3635         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
3636     mockService.addResponse(expectedResponse);
3637 
3638     TestIamPermissionsRequest request =
3639         TestIamPermissionsRequest.newBuilder()
3640             .setResource(
3641                 ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
3642                     .toString())
3643             .addAllPermissions(new ArrayList<String>())
3644             .build();
3645 
3646     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
3647     Assert.assertEquals(expectedResponse, actualResponse);
3648 
3649     List<String> actualRequests = mockService.getRequestPaths();
3650     Assert.assertEquals(1, actualRequests.size());
3651 
3652     String apiClientHeaderKey =
3653         mockService
3654             .getRequestHeaders()
3655             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3656             .iterator()
3657             .next();
3658     Assert.assertTrue(
3659         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3660             .matcher(apiClientHeaderKey)
3661             .matches());
3662   }
3663 
3664   @Test
testIamPermissionsExceptionTest()3665   public void testIamPermissionsExceptionTest() throws Exception {
3666     ApiException exception =
3667         ApiExceptionFactory.createException(
3668             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3669     mockService.addException(exception);
3670 
3671     try {
3672       TestIamPermissionsRequest request =
3673           TestIamPermissionsRequest.newBuilder()
3674               .setResource(
3675                   ClusterName.of("[PROJECT]", "[LOCATION]", "[PRIVATE_CLOUD]", "[CLUSTER]")
3676                       .toString())
3677               .addAllPermissions(new ArrayList<String>())
3678               .build();
3679       client.testIamPermissions(request);
3680       Assert.fail("No exception raised");
3681     } catch (InvalidArgumentException e) {
3682       // Expected exception.
3683     }
3684   }
3685 }
3686