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.compute.v1;
18 
19 import static com.google.cloud.compute.v1.InstancesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.InstancesClient.ListPagedResponse;
21 import static com.google.cloud.compute.v1.InstancesClient.ListReferrersPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
25 import com.google.api.gax.httpjson.testing.MockHttpService;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.ApiException;
28 import com.google.api.gax.rpc.ApiExceptionFactory;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.api.gax.rpc.testing.FakeStatusCode;
32 import com.google.cloud.compute.v1.Operation.Status;
33 import com.google.cloud.compute.v1.stub.HttpJsonInstancesStub;
34 import com.google.common.collect.Lists;
35 import java.io.IOException;
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.Collections;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Map;
42 import java.util.concurrent.ExecutionException;
43 import javax.annotation.Generated;
44 import org.junit.After;
45 import org.junit.AfterClass;
46 import org.junit.Assert;
47 import org.junit.Before;
48 import org.junit.BeforeClass;
49 import org.junit.Test;
50 
51 @Generated("by gapic-generator-java")
52 public class InstancesClientTest {
53   private static MockHttpService mockService;
54   private static InstancesClient client;
55 
56   @BeforeClass
startStaticServer()57   public static void startStaticServer() throws IOException {
58     mockService =
59         new MockHttpService(
60             HttpJsonInstancesStub.getMethodDescriptors(), InstancesSettings.getDefaultEndpoint());
61     InstancesSettings settings =
62         InstancesSettings.newBuilder()
63             .setTransportChannelProvider(
64                 InstancesSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = InstancesClient.create(settings);
70   }
71 
72   @AfterClass
stopServer()73   public static void stopServer() {
74     client.close();
75   }
76 
77   @Before
setUp()78   public void setUp() {}
79 
80   @After
tearDown()81   public void tearDown() throws Exception {
82     mockService.reset();
83   }
84 
85   @Test
addAccessConfigTest()86   public void addAccessConfigTest() throws Exception {
87     Operation expectedResponse =
88         Operation.newBuilder()
89             .setClientOperationId("clientOperationId-1230366697")
90             .setCreationTimestamp("creationTimestamp-370203401")
91             .setDescription("description-1724546052")
92             .setEndTime("endTime-1607243192")
93             .setError(Error.newBuilder().build())
94             .setHttpErrorMessage("httpErrorMessage1577303431")
95             .setHttpErrorStatusCode(0)
96             .setId(3355)
97             .setInsertTime("insertTime966165798")
98             .setKind("kind3292052")
99             .setName("name3373707")
100             .setOperationGroupId("operationGroupId1716161683")
101             .setOperationType("operationType91999553")
102             .setProgress(-1001078227)
103             .setRegion("region-934795532")
104             .setSelfLink("selfLink1191800166")
105             .setStartTime("startTime-2129294769")
106             .setStatus(Status.DONE)
107             .setStatusMessage("statusMessage-958704715")
108             .setTargetId(-815576439)
109             .setTargetLink("targetLink486368555")
110             .setUser("user3599307")
111             .addAllWarnings(new ArrayList<Warnings>())
112             .setZone("zone3744684")
113             .build();
114     mockService.addResponse(expectedResponse);
115 
116     String project = "project-6911";
117     String zone = "zone-5246";
118     String instance = "instance-7525";
119     String networkInterface = "networkInterface-341981525";
120     AccessConfig accessConfigResource = AccessConfig.newBuilder().build();
121 
122     Operation actualResponse =
123         client
124             .addAccessConfigAsync(project, zone, instance, networkInterface, accessConfigResource)
125             .get();
126     Assert.assertEquals(expectedResponse, actualResponse);
127 
128     List<String> actualRequests = mockService.getRequestPaths();
129     Assert.assertEquals(1, actualRequests.size());
130 
131     String apiClientHeaderKey =
132         mockService
133             .getRequestHeaders()
134             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
135             .iterator()
136             .next();
137     Assert.assertTrue(
138         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
139             .matcher(apiClientHeaderKey)
140             .matches());
141   }
142 
143   @Test
addAccessConfigExceptionTest()144   public void addAccessConfigExceptionTest() throws Exception {
145     ApiException exception =
146         ApiExceptionFactory.createException(
147             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
148     mockService.addException(exception);
149 
150     try {
151       String project = "project-6911";
152       String zone = "zone-5246";
153       String instance = "instance-7525";
154       String networkInterface = "networkInterface-341981525";
155       AccessConfig accessConfigResource = AccessConfig.newBuilder().build();
156       client
157           .addAccessConfigAsync(project, zone, instance, networkInterface, accessConfigResource)
158           .get();
159       Assert.fail("No exception raised");
160     } catch (ExecutionException e) {
161     }
162   }
163 
164   @Test
addResourcePoliciesTest()165   public void addResourcePoliciesTest() throws Exception {
166     Operation expectedResponse =
167         Operation.newBuilder()
168             .setClientOperationId("clientOperationId-1230366697")
169             .setCreationTimestamp("creationTimestamp-370203401")
170             .setDescription("description-1724546052")
171             .setEndTime("endTime-1607243192")
172             .setError(Error.newBuilder().build())
173             .setHttpErrorMessage("httpErrorMessage1577303431")
174             .setHttpErrorStatusCode(0)
175             .setId(3355)
176             .setInsertTime("insertTime966165798")
177             .setKind("kind3292052")
178             .setName("name3373707")
179             .setOperationGroupId("operationGroupId1716161683")
180             .setOperationType("operationType91999553")
181             .setProgress(-1001078227)
182             .setRegion("region-934795532")
183             .setSelfLink("selfLink1191800166")
184             .setStartTime("startTime-2129294769")
185             .setStatus(Status.DONE)
186             .setStatusMessage("statusMessage-958704715")
187             .setTargetId(-815576439)
188             .setTargetLink("targetLink486368555")
189             .setUser("user3599307")
190             .addAllWarnings(new ArrayList<Warnings>())
191             .setZone("zone3744684")
192             .build();
193     mockService.addResponse(expectedResponse);
194 
195     String project = "project-6911";
196     String zone = "zone-5246";
197     String instance = "instance-7525";
198     InstancesAddResourcePoliciesRequest instancesAddResourcePoliciesRequestResource =
199         InstancesAddResourcePoliciesRequest.newBuilder().build();
200 
201     Operation actualResponse =
202         client
203             .addResourcePoliciesAsync(
204                 project, zone, instance, instancesAddResourcePoliciesRequestResource)
205             .get();
206     Assert.assertEquals(expectedResponse, actualResponse);
207 
208     List<String> actualRequests = mockService.getRequestPaths();
209     Assert.assertEquals(1, actualRequests.size());
210 
211     String apiClientHeaderKey =
212         mockService
213             .getRequestHeaders()
214             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
215             .iterator()
216             .next();
217     Assert.assertTrue(
218         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
219             .matcher(apiClientHeaderKey)
220             .matches());
221   }
222 
223   @Test
addResourcePoliciesExceptionTest()224   public void addResourcePoliciesExceptionTest() throws Exception {
225     ApiException exception =
226         ApiExceptionFactory.createException(
227             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
228     mockService.addException(exception);
229 
230     try {
231       String project = "project-6911";
232       String zone = "zone-5246";
233       String instance = "instance-7525";
234       InstancesAddResourcePoliciesRequest instancesAddResourcePoliciesRequestResource =
235           InstancesAddResourcePoliciesRequest.newBuilder().build();
236       client
237           .addResourcePoliciesAsync(
238               project, zone, instance, instancesAddResourcePoliciesRequestResource)
239           .get();
240       Assert.fail("No exception raised");
241     } catch (ExecutionException e) {
242     }
243   }
244 
245   @Test
aggregatedListTest()246   public void aggregatedListTest() throws Exception {
247     InstancesScopedList responsesElement = InstancesScopedList.newBuilder().build();
248     InstanceAggregatedList expectedResponse =
249         InstanceAggregatedList.newBuilder()
250             .setNextPageToken("")
251             .putAllItems(Collections.singletonMap("items", responsesElement))
252             .build();
253     mockService.addResponse(expectedResponse);
254 
255     String project = "project-6911";
256 
257     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
258 
259     List<Map.Entry<String, InstancesScopedList>> resources =
260         Lists.newArrayList(pagedListResponse.iterateAll());
261 
262     Assert.assertEquals(1, resources.size());
263     Assert.assertEquals(
264         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
265 
266     List<String> actualRequests = mockService.getRequestPaths();
267     Assert.assertEquals(1, actualRequests.size());
268 
269     String apiClientHeaderKey =
270         mockService
271             .getRequestHeaders()
272             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
273             .iterator()
274             .next();
275     Assert.assertTrue(
276         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
277             .matcher(apiClientHeaderKey)
278             .matches());
279   }
280 
281   @Test
aggregatedListExceptionTest()282   public void aggregatedListExceptionTest() throws Exception {
283     ApiException exception =
284         ApiExceptionFactory.createException(
285             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
286     mockService.addException(exception);
287 
288     try {
289       String project = "project-6911";
290       client.aggregatedList(project);
291       Assert.fail("No exception raised");
292     } catch (InvalidArgumentException e) {
293       // Expected exception.
294     }
295   }
296 
297   @Test
attachDiskTest()298   public void attachDiskTest() throws Exception {
299     Operation expectedResponse =
300         Operation.newBuilder()
301             .setClientOperationId("clientOperationId-1230366697")
302             .setCreationTimestamp("creationTimestamp-370203401")
303             .setDescription("description-1724546052")
304             .setEndTime("endTime-1607243192")
305             .setError(Error.newBuilder().build())
306             .setHttpErrorMessage("httpErrorMessage1577303431")
307             .setHttpErrorStatusCode(0)
308             .setId(3355)
309             .setInsertTime("insertTime966165798")
310             .setKind("kind3292052")
311             .setName("name3373707")
312             .setOperationGroupId("operationGroupId1716161683")
313             .setOperationType("operationType91999553")
314             .setProgress(-1001078227)
315             .setRegion("region-934795532")
316             .setSelfLink("selfLink1191800166")
317             .setStartTime("startTime-2129294769")
318             .setStatus(Status.DONE)
319             .setStatusMessage("statusMessage-958704715")
320             .setTargetId(-815576439)
321             .setTargetLink("targetLink486368555")
322             .setUser("user3599307")
323             .addAllWarnings(new ArrayList<Warnings>())
324             .setZone("zone3744684")
325             .build();
326     mockService.addResponse(expectedResponse);
327 
328     String project = "project-6911";
329     String zone = "zone-5246";
330     String instance = "instance-7525";
331     AttachedDisk attachedDiskResource = AttachedDisk.newBuilder().build();
332 
333     Operation actualResponse =
334         client.attachDiskAsync(project, zone, instance, attachedDiskResource).get();
335     Assert.assertEquals(expectedResponse, actualResponse);
336 
337     List<String> actualRequests = mockService.getRequestPaths();
338     Assert.assertEquals(1, actualRequests.size());
339 
340     String apiClientHeaderKey =
341         mockService
342             .getRequestHeaders()
343             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
344             .iterator()
345             .next();
346     Assert.assertTrue(
347         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
348             .matcher(apiClientHeaderKey)
349             .matches());
350   }
351 
352   @Test
attachDiskExceptionTest()353   public void attachDiskExceptionTest() throws Exception {
354     ApiException exception =
355         ApiExceptionFactory.createException(
356             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
357     mockService.addException(exception);
358 
359     try {
360       String project = "project-6911";
361       String zone = "zone-5246";
362       String instance = "instance-7525";
363       AttachedDisk attachedDiskResource = AttachedDisk.newBuilder().build();
364       client.attachDiskAsync(project, zone, instance, attachedDiskResource).get();
365       Assert.fail("No exception raised");
366     } catch (ExecutionException e) {
367     }
368   }
369 
370   @Test
bulkInsertTest()371   public void bulkInsertTest() throws Exception {
372     Operation expectedResponse =
373         Operation.newBuilder()
374             .setClientOperationId("clientOperationId-1230366697")
375             .setCreationTimestamp("creationTimestamp-370203401")
376             .setDescription("description-1724546052")
377             .setEndTime("endTime-1607243192")
378             .setError(Error.newBuilder().build())
379             .setHttpErrorMessage("httpErrorMessage1577303431")
380             .setHttpErrorStatusCode(0)
381             .setId(3355)
382             .setInsertTime("insertTime966165798")
383             .setKind("kind3292052")
384             .setName("name3373707")
385             .setOperationGroupId("operationGroupId1716161683")
386             .setOperationType("operationType91999553")
387             .setProgress(-1001078227)
388             .setRegion("region-934795532")
389             .setSelfLink("selfLink1191800166")
390             .setStartTime("startTime-2129294769")
391             .setStatus(Status.DONE)
392             .setStatusMessage("statusMessage-958704715")
393             .setTargetId(-815576439)
394             .setTargetLink("targetLink486368555")
395             .setUser("user3599307")
396             .addAllWarnings(new ArrayList<Warnings>())
397             .setZone("zone3744684")
398             .build();
399     mockService.addResponse(expectedResponse);
400 
401     String project = "project-6911";
402     String zone = "zone-5246";
403     BulkInsertInstanceResource bulkInsertInstanceResourceResource =
404         BulkInsertInstanceResource.newBuilder().build();
405 
406     Operation actualResponse =
407         client.bulkInsertAsync(project, zone, bulkInsertInstanceResourceResource).get();
408     Assert.assertEquals(expectedResponse, actualResponse);
409 
410     List<String> actualRequests = mockService.getRequestPaths();
411     Assert.assertEquals(1, actualRequests.size());
412 
413     String apiClientHeaderKey =
414         mockService
415             .getRequestHeaders()
416             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
417             .iterator()
418             .next();
419     Assert.assertTrue(
420         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
421             .matcher(apiClientHeaderKey)
422             .matches());
423   }
424 
425   @Test
bulkInsertExceptionTest()426   public void bulkInsertExceptionTest() throws Exception {
427     ApiException exception =
428         ApiExceptionFactory.createException(
429             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
430     mockService.addException(exception);
431 
432     try {
433       String project = "project-6911";
434       String zone = "zone-5246";
435       BulkInsertInstanceResource bulkInsertInstanceResourceResource =
436           BulkInsertInstanceResource.newBuilder().build();
437       client.bulkInsertAsync(project, zone, bulkInsertInstanceResourceResource).get();
438       Assert.fail("No exception raised");
439     } catch (ExecutionException e) {
440     }
441   }
442 
443   @Test
deleteTest()444   public void deleteTest() throws Exception {
445     Operation expectedResponse =
446         Operation.newBuilder()
447             .setClientOperationId("clientOperationId-1230366697")
448             .setCreationTimestamp("creationTimestamp-370203401")
449             .setDescription("description-1724546052")
450             .setEndTime("endTime-1607243192")
451             .setError(Error.newBuilder().build())
452             .setHttpErrorMessage("httpErrorMessage1577303431")
453             .setHttpErrorStatusCode(0)
454             .setId(3355)
455             .setInsertTime("insertTime966165798")
456             .setKind("kind3292052")
457             .setName("name3373707")
458             .setOperationGroupId("operationGroupId1716161683")
459             .setOperationType("operationType91999553")
460             .setProgress(-1001078227)
461             .setRegion("region-934795532")
462             .setSelfLink("selfLink1191800166")
463             .setStartTime("startTime-2129294769")
464             .setStatus(Status.DONE)
465             .setStatusMessage("statusMessage-958704715")
466             .setTargetId(-815576439)
467             .setTargetLink("targetLink486368555")
468             .setUser("user3599307")
469             .addAllWarnings(new ArrayList<Warnings>())
470             .setZone("zone3744684")
471             .build();
472     mockService.addResponse(expectedResponse);
473 
474     String project = "project-6911";
475     String zone = "zone-5246";
476     String instance = "instance-7525";
477 
478     Operation actualResponse = client.deleteAsync(project, zone, instance).get();
479     Assert.assertEquals(expectedResponse, actualResponse);
480 
481     List<String> actualRequests = mockService.getRequestPaths();
482     Assert.assertEquals(1, actualRequests.size());
483 
484     String apiClientHeaderKey =
485         mockService
486             .getRequestHeaders()
487             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
488             .iterator()
489             .next();
490     Assert.assertTrue(
491         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
492             .matcher(apiClientHeaderKey)
493             .matches());
494   }
495 
496   @Test
deleteExceptionTest()497   public void deleteExceptionTest() throws Exception {
498     ApiException exception =
499         ApiExceptionFactory.createException(
500             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
501     mockService.addException(exception);
502 
503     try {
504       String project = "project-6911";
505       String zone = "zone-5246";
506       String instance = "instance-7525";
507       client.deleteAsync(project, zone, instance).get();
508       Assert.fail("No exception raised");
509     } catch (ExecutionException e) {
510     }
511   }
512 
513   @Test
deleteAccessConfigTest()514   public void deleteAccessConfigTest() throws Exception {
515     Operation expectedResponse =
516         Operation.newBuilder()
517             .setClientOperationId("clientOperationId-1230366697")
518             .setCreationTimestamp("creationTimestamp-370203401")
519             .setDescription("description-1724546052")
520             .setEndTime("endTime-1607243192")
521             .setError(Error.newBuilder().build())
522             .setHttpErrorMessage("httpErrorMessage1577303431")
523             .setHttpErrorStatusCode(0)
524             .setId(3355)
525             .setInsertTime("insertTime966165798")
526             .setKind("kind3292052")
527             .setName("name3373707")
528             .setOperationGroupId("operationGroupId1716161683")
529             .setOperationType("operationType91999553")
530             .setProgress(-1001078227)
531             .setRegion("region-934795532")
532             .setSelfLink("selfLink1191800166")
533             .setStartTime("startTime-2129294769")
534             .setStatus(Status.DONE)
535             .setStatusMessage("statusMessage-958704715")
536             .setTargetId(-815576439)
537             .setTargetLink("targetLink486368555")
538             .setUser("user3599307")
539             .addAllWarnings(new ArrayList<Warnings>())
540             .setZone("zone3744684")
541             .build();
542     mockService.addResponse(expectedResponse);
543 
544     String project = "project-6911";
545     String zone = "zone-5246";
546     String instance = "instance-7525";
547     String accessConfig = "accessConfig1549765062";
548     String networkInterface = "networkInterface-341981525";
549 
550     Operation actualResponse =
551         client
552             .deleteAccessConfigAsync(project, zone, instance, accessConfig, networkInterface)
553             .get();
554     Assert.assertEquals(expectedResponse, actualResponse);
555 
556     List<String> actualRequests = mockService.getRequestPaths();
557     Assert.assertEquals(1, actualRequests.size());
558 
559     String apiClientHeaderKey =
560         mockService
561             .getRequestHeaders()
562             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
563             .iterator()
564             .next();
565     Assert.assertTrue(
566         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
567             .matcher(apiClientHeaderKey)
568             .matches());
569   }
570 
571   @Test
deleteAccessConfigExceptionTest()572   public void deleteAccessConfigExceptionTest() throws Exception {
573     ApiException exception =
574         ApiExceptionFactory.createException(
575             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
576     mockService.addException(exception);
577 
578     try {
579       String project = "project-6911";
580       String zone = "zone-5246";
581       String instance = "instance-7525";
582       String accessConfig = "accessConfig1549765062";
583       String networkInterface = "networkInterface-341981525";
584       client.deleteAccessConfigAsync(project, zone, instance, accessConfig, networkInterface).get();
585       Assert.fail("No exception raised");
586     } catch (ExecutionException e) {
587     }
588   }
589 
590   @Test
detachDiskTest()591   public void detachDiskTest() throws Exception {
592     Operation expectedResponse =
593         Operation.newBuilder()
594             .setClientOperationId("clientOperationId-1230366697")
595             .setCreationTimestamp("creationTimestamp-370203401")
596             .setDescription("description-1724546052")
597             .setEndTime("endTime-1607243192")
598             .setError(Error.newBuilder().build())
599             .setHttpErrorMessage("httpErrorMessage1577303431")
600             .setHttpErrorStatusCode(0)
601             .setId(3355)
602             .setInsertTime("insertTime966165798")
603             .setKind("kind3292052")
604             .setName("name3373707")
605             .setOperationGroupId("operationGroupId1716161683")
606             .setOperationType("operationType91999553")
607             .setProgress(-1001078227)
608             .setRegion("region-934795532")
609             .setSelfLink("selfLink1191800166")
610             .setStartTime("startTime-2129294769")
611             .setStatus(Status.DONE)
612             .setStatusMessage("statusMessage-958704715")
613             .setTargetId(-815576439)
614             .setTargetLink("targetLink486368555")
615             .setUser("user3599307")
616             .addAllWarnings(new ArrayList<Warnings>())
617             .setZone("zone3744684")
618             .build();
619     mockService.addResponse(expectedResponse);
620 
621     String project = "project-6911";
622     String zone = "zone-5246";
623     String instance = "instance-7525";
624     String deviceName = "deviceName780988929";
625 
626     Operation actualResponse = client.detachDiskAsync(project, zone, instance, deviceName).get();
627     Assert.assertEquals(expectedResponse, actualResponse);
628 
629     List<String> actualRequests = mockService.getRequestPaths();
630     Assert.assertEquals(1, actualRequests.size());
631 
632     String apiClientHeaderKey =
633         mockService
634             .getRequestHeaders()
635             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
636             .iterator()
637             .next();
638     Assert.assertTrue(
639         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
640             .matcher(apiClientHeaderKey)
641             .matches());
642   }
643 
644   @Test
detachDiskExceptionTest()645   public void detachDiskExceptionTest() throws Exception {
646     ApiException exception =
647         ApiExceptionFactory.createException(
648             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
649     mockService.addException(exception);
650 
651     try {
652       String project = "project-6911";
653       String zone = "zone-5246";
654       String instance = "instance-7525";
655       String deviceName = "deviceName780988929";
656       client.detachDiskAsync(project, zone, instance, deviceName).get();
657       Assert.fail("No exception raised");
658     } catch (ExecutionException e) {
659     }
660   }
661 
662   @Test
getTest()663   public void getTest() throws Exception {
664     Instance expectedResponse =
665         Instance.newBuilder()
666             .setAdvancedMachineFeatures(AdvancedMachineFeatures.newBuilder().build())
667             .setCanIpForward(true)
668             .setConfidentialInstanceConfig(ConfidentialInstanceConfig.newBuilder().build())
669             .setCpuPlatform("cpuPlatform-1418648005")
670             .setCreationTimestamp("creationTimestamp-370203401")
671             .setDeletionProtection(true)
672             .setDescription("description-1724546052")
673             .addAllDisks(new ArrayList<AttachedDisk>())
674             .setDisplayDevice(DisplayDevice.newBuilder().build())
675             .setFingerprint("fingerprint-1375934236")
676             .addAllGuestAccelerators(new ArrayList<AcceleratorConfig>())
677             .setHostname("hostname-299803597")
678             .setId(3355)
679             .setKeyRevocationActionType("keyRevocationActionType-1643749939")
680             .setKind("kind3292052")
681             .setLabelFingerprint("labelFingerprint379449680")
682             .putAllLabels(new HashMap<String, String>())
683             .setLastStartTimestamp("lastStartTimestamp1011643146")
684             .setLastStopTimestamp("lastStopTimestamp-251714498")
685             .setLastSuspendedTimestamp("lastSuspendedTimestamp1116944049")
686             .setMachineType("machineType-218117087")
687             .setMetadata(Metadata.newBuilder().build())
688             .setMinCpuPlatform("minCpuPlatform1549557897")
689             .setName("name3373707")
690             .addAllNetworkInterfaces(new ArrayList<NetworkInterface>())
691             .setNetworkPerformanceConfig(NetworkPerformanceConfig.newBuilder().build())
692             .setParams(InstanceParams.newBuilder().build())
693             .setPrivateIpv6GoogleAccess("privateIpv6GoogleAccess-1729571801")
694             .setReservationAffinity(ReservationAffinity.newBuilder().build())
695             .addAllResourcePolicies(new ArrayList<String>())
696             .setResourceStatus(ResourceStatus.newBuilder().build())
697             .setSatisfiesPzs(true)
698             .setScheduling(Scheduling.newBuilder().build())
699             .setSelfLink("selfLink1191800166")
700             .addAllServiceAccounts(new ArrayList<ServiceAccount>())
701             .setShieldedInstanceConfig(ShieldedInstanceConfig.newBuilder().build())
702             .setShieldedInstanceIntegrityPolicy(
703                 ShieldedInstanceIntegrityPolicy.newBuilder().build())
704             .setSourceMachineImage("sourceMachineImage1261073679")
705             .setSourceMachineImageEncryptionKey(CustomerEncryptionKey.newBuilder().build())
706             .setStartRestricted(true)
707             .setStatus("status-892481550")
708             .setStatusMessage("statusMessage-958704715")
709             .setTags(Tags.newBuilder().build())
710             .setZone("zone3744684")
711             .build();
712     mockService.addResponse(expectedResponse);
713 
714     String project = "project-6911";
715     String zone = "zone-5246";
716     String instance = "instance-7525";
717 
718     Instance actualResponse = client.get(project, zone, instance);
719     Assert.assertEquals(expectedResponse, actualResponse);
720 
721     List<String> actualRequests = mockService.getRequestPaths();
722     Assert.assertEquals(1, actualRequests.size());
723 
724     String apiClientHeaderKey =
725         mockService
726             .getRequestHeaders()
727             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
728             .iterator()
729             .next();
730     Assert.assertTrue(
731         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
732             .matcher(apiClientHeaderKey)
733             .matches());
734   }
735 
736   @Test
getExceptionTest()737   public void getExceptionTest() throws Exception {
738     ApiException exception =
739         ApiExceptionFactory.createException(
740             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
741     mockService.addException(exception);
742 
743     try {
744       String project = "project-6911";
745       String zone = "zone-5246";
746       String instance = "instance-7525";
747       client.get(project, zone, instance);
748       Assert.fail("No exception raised");
749     } catch (InvalidArgumentException e) {
750       // Expected exception.
751     }
752   }
753 
754   @Test
getEffectiveFirewallsTest()755   public void getEffectiveFirewallsTest() throws Exception {
756     InstancesGetEffectiveFirewallsResponse expectedResponse =
757         InstancesGetEffectiveFirewallsResponse.newBuilder()
758             .addAllFirewallPolicys(
759                 new ArrayList<InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy>())
760             .addAllFirewalls(new ArrayList<Firewall>())
761             .build();
762     mockService.addResponse(expectedResponse);
763 
764     String project = "project-6911";
765     String zone = "zone-5246";
766     String instance = "instance-7525";
767     String networkInterface = "networkInterface-341981525";
768 
769     InstancesGetEffectiveFirewallsResponse actualResponse =
770         client.getEffectiveFirewalls(project, zone, instance, networkInterface);
771     Assert.assertEquals(expectedResponse, actualResponse);
772 
773     List<String> actualRequests = mockService.getRequestPaths();
774     Assert.assertEquals(1, actualRequests.size());
775 
776     String apiClientHeaderKey =
777         mockService
778             .getRequestHeaders()
779             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
780             .iterator()
781             .next();
782     Assert.assertTrue(
783         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
784             .matcher(apiClientHeaderKey)
785             .matches());
786   }
787 
788   @Test
getEffectiveFirewallsExceptionTest()789   public void getEffectiveFirewallsExceptionTest() throws Exception {
790     ApiException exception =
791         ApiExceptionFactory.createException(
792             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
793     mockService.addException(exception);
794 
795     try {
796       String project = "project-6911";
797       String zone = "zone-5246";
798       String instance = "instance-7525";
799       String networkInterface = "networkInterface-341981525";
800       client.getEffectiveFirewalls(project, zone, instance, networkInterface);
801       Assert.fail("No exception raised");
802     } catch (InvalidArgumentException e) {
803       // Expected exception.
804     }
805   }
806 
807   @Test
getGuestAttributesTest()808   public void getGuestAttributesTest() throws Exception {
809     GuestAttributes expectedResponse =
810         GuestAttributes.newBuilder()
811             .setKind("kind3292052")
812             .setQueryPath("queryPath-1807004403")
813             .setQueryValue(GuestAttributesValue.newBuilder().build())
814             .setSelfLink("selfLink1191800166")
815             .setVariableKey("variableKey-1951698365")
816             .setVariableValue("variableValue1328610389")
817             .build();
818     mockService.addResponse(expectedResponse);
819 
820     String project = "project-6911";
821     String zone = "zone-5246";
822     String instance = "instance-7525";
823 
824     GuestAttributes actualResponse = client.getGuestAttributes(project, zone, instance);
825     Assert.assertEquals(expectedResponse, actualResponse);
826 
827     List<String> actualRequests = mockService.getRequestPaths();
828     Assert.assertEquals(1, actualRequests.size());
829 
830     String apiClientHeaderKey =
831         mockService
832             .getRequestHeaders()
833             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
834             .iterator()
835             .next();
836     Assert.assertTrue(
837         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
838             .matcher(apiClientHeaderKey)
839             .matches());
840   }
841 
842   @Test
getGuestAttributesExceptionTest()843   public void getGuestAttributesExceptionTest() throws Exception {
844     ApiException exception =
845         ApiExceptionFactory.createException(
846             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
847     mockService.addException(exception);
848 
849     try {
850       String project = "project-6911";
851       String zone = "zone-5246";
852       String instance = "instance-7525";
853       client.getGuestAttributes(project, zone, instance);
854       Assert.fail("No exception raised");
855     } catch (InvalidArgumentException e) {
856       // Expected exception.
857     }
858   }
859 
860   @Test
getIamPolicyTest()861   public void getIamPolicyTest() throws Exception {
862     Policy expectedResponse =
863         Policy.newBuilder()
864             .addAllAuditConfigs(new ArrayList<AuditConfig>())
865             .addAllBindings(new ArrayList<Binding>())
866             .setEtag("etag3123477")
867             .setIamOwned(true)
868             .addAllRules(new ArrayList<Rule>())
869             .setVersion(351608024)
870             .build();
871     mockService.addResponse(expectedResponse);
872 
873     String project = "project-6911";
874     String zone = "zone-5246";
875     String resource = "resource-756";
876 
877     Policy actualResponse = client.getIamPolicy(project, zone, resource);
878     Assert.assertEquals(expectedResponse, actualResponse);
879 
880     List<String> actualRequests = mockService.getRequestPaths();
881     Assert.assertEquals(1, actualRequests.size());
882 
883     String apiClientHeaderKey =
884         mockService
885             .getRequestHeaders()
886             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
887             .iterator()
888             .next();
889     Assert.assertTrue(
890         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
891             .matcher(apiClientHeaderKey)
892             .matches());
893   }
894 
895   @Test
getIamPolicyExceptionTest()896   public void getIamPolicyExceptionTest() throws Exception {
897     ApiException exception =
898         ApiExceptionFactory.createException(
899             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
900     mockService.addException(exception);
901 
902     try {
903       String project = "project-6911";
904       String zone = "zone-5246";
905       String resource = "resource-756";
906       client.getIamPolicy(project, zone, resource);
907       Assert.fail("No exception raised");
908     } catch (InvalidArgumentException e) {
909       // Expected exception.
910     }
911   }
912 
913   @Test
getScreenshotTest()914   public void getScreenshotTest() throws Exception {
915     Screenshot expectedResponse =
916         Screenshot.newBuilder().setContents("contents-567321830").setKind("kind3292052").build();
917     mockService.addResponse(expectedResponse);
918 
919     String project = "project-6911";
920     String zone = "zone-5246";
921     String instance = "instance-7525";
922 
923     Screenshot actualResponse = client.getScreenshot(project, zone, instance);
924     Assert.assertEquals(expectedResponse, actualResponse);
925 
926     List<String> actualRequests = mockService.getRequestPaths();
927     Assert.assertEquals(1, actualRequests.size());
928 
929     String apiClientHeaderKey =
930         mockService
931             .getRequestHeaders()
932             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
933             .iterator()
934             .next();
935     Assert.assertTrue(
936         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
937             .matcher(apiClientHeaderKey)
938             .matches());
939   }
940 
941   @Test
getScreenshotExceptionTest()942   public void getScreenshotExceptionTest() throws Exception {
943     ApiException exception =
944         ApiExceptionFactory.createException(
945             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
946     mockService.addException(exception);
947 
948     try {
949       String project = "project-6911";
950       String zone = "zone-5246";
951       String instance = "instance-7525";
952       client.getScreenshot(project, zone, instance);
953       Assert.fail("No exception raised");
954     } catch (InvalidArgumentException e) {
955       // Expected exception.
956     }
957   }
958 
959   @Test
getSerialPortOutputTest()960   public void getSerialPortOutputTest() throws Exception {
961     SerialPortOutput expectedResponse =
962         SerialPortOutput.newBuilder()
963             .setContents("contents-567321830")
964             .setKind("kind3292052")
965             .setNext(3377907)
966             .setSelfLink("selfLink1191800166")
967             .setStart(109757538)
968             .build();
969     mockService.addResponse(expectedResponse);
970 
971     String project = "project-6911";
972     String zone = "zone-5246";
973     String instance = "instance-7525";
974 
975     SerialPortOutput actualResponse = client.getSerialPortOutput(project, zone, instance);
976     Assert.assertEquals(expectedResponse, actualResponse);
977 
978     List<String> actualRequests = mockService.getRequestPaths();
979     Assert.assertEquals(1, actualRequests.size());
980 
981     String apiClientHeaderKey =
982         mockService
983             .getRequestHeaders()
984             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
985             .iterator()
986             .next();
987     Assert.assertTrue(
988         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
989             .matcher(apiClientHeaderKey)
990             .matches());
991   }
992 
993   @Test
getSerialPortOutputExceptionTest()994   public void getSerialPortOutputExceptionTest() throws Exception {
995     ApiException exception =
996         ApiExceptionFactory.createException(
997             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
998     mockService.addException(exception);
999 
1000     try {
1001       String project = "project-6911";
1002       String zone = "zone-5246";
1003       String instance = "instance-7525";
1004       client.getSerialPortOutput(project, zone, instance);
1005       Assert.fail("No exception raised");
1006     } catch (InvalidArgumentException e) {
1007       // Expected exception.
1008     }
1009   }
1010 
1011   @Test
getShieldedInstanceIdentityTest()1012   public void getShieldedInstanceIdentityTest() throws Exception {
1013     ShieldedInstanceIdentity expectedResponse =
1014         ShieldedInstanceIdentity.newBuilder()
1015             .setEncryptionKey(ShieldedInstanceIdentityEntry.newBuilder().build())
1016             .setKind("kind3292052")
1017             .setSigningKey(ShieldedInstanceIdentityEntry.newBuilder().build())
1018             .build();
1019     mockService.addResponse(expectedResponse);
1020 
1021     String project = "project-6911";
1022     String zone = "zone-5246";
1023     String instance = "instance-7525";
1024 
1025     ShieldedInstanceIdentity actualResponse =
1026         client.getShieldedInstanceIdentity(project, zone, instance);
1027     Assert.assertEquals(expectedResponse, actualResponse);
1028 
1029     List<String> actualRequests = mockService.getRequestPaths();
1030     Assert.assertEquals(1, actualRequests.size());
1031 
1032     String apiClientHeaderKey =
1033         mockService
1034             .getRequestHeaders()
1035             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1036             .iterator()
1037             .next();
1038     Assert.assertTrue(
1039         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1040             .matcher(apiClientHeaderKey)
1041             .matches());
1042   }
1043 
1044   @Test
getShieldedInstanceIdentityExceptionTest()1045   public void getShieldedInstanceIdentityExceptionTest() throws Exception {
1046     ApiException exception =
1047         ApiExceptionFactory.createException(
1048             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1049     mockService.addException(exception);
1050 
1051     try {
1052       String project = "project-6911";
1053       String zone = "zone-5246";
1054       String instance = "instance-7525";
1055       client.getShieldedInstanceIdentity(project, zone, instance);
1056       Assert.fail("No exception raised");
1057     } catch (InvalidArgumentException e) {
1058       // Expected exception.
1059     }
1060   }
1061 
1062   @Test
insertTest()1063   public void insertTest() throws Exception {
1064     Operation expectedResponse =
1065         Operation.newBuilder()
1066             .setClientOperationId("clientOperationId-1230366697")
1067             .setCreationTimestamp("creationTimestamp-370203401")
1068             .setDescription("description-1724546052")
1069             .setEndTime("endTime-1607243192")
1070             .setError(Error.newBuilder().build())
1071             .setHttpErrorMessage("httpErrorMessage1577303431")
1072             .setHttpErrorStatusCode(0)
1073             .setId(3355)
1074             .setInsertTime("insertTime966165798")
1075             .setKind("kind3292052")
1076             .setName("name3373707")
1077             .setOperationGroupId("operationGroupId1716161683")
1078             .setOperationType("operationType91999553")
1079             .setProgress(-1001078227)
1080             .setRegion("region-934795532")
1081             .setSelfLink("selfLink1191800166")
1082             .setStartTime("startTime-2129294769")
1083             .setStatus(Status.DONE)
1084             .setStatusMessage("statusMessage-958704715")
1085             .setTargetId(-815576439)
1086             .setTargetLink("targetLink486368555")
1087             .setUser("user3599307")
1088             .addAllWarnings(new ArrayList<Warnings>())
1089             .setZone("zone3744684")
1090             .build();
1091     mockService.addResponse(expectedResponse);
1092 
1093     String project = "project-6911";
1094     String zone = "zone-5246";
1095     Instance instanceResource = Instance.newBuilder().build();
1096 
1097     Operation actualResponse = client.insertAsync(project, zone, instanceResource).get();
1098     Assert.assertEquals(expectedResponse, actualResponse);
1099 
1100     List<String> actualRequests = mockService.getRequestPaths();
1101     Assert.assertEquals(1, actualRequests.size());
1102 
1103     String apiClientHeaderKey =
1104         mockService
1105             .getRequestHeaders()
1106             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1107             .iterator()
1108             .next();
1109     Assert.assertTrue(
1110         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1111             .matcher(apiClientHeaderKey)
1112             .matches());
1113   }
1114 
1115   @Test
insertExceptionTest()1116   public void insertExceptionTest() throws Exception {
1117     ApiException exception =
1118         ApiExceptionFactory.createException(
1119             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1120     mockService.addException(exception);
1121 
1122     try {
1123       String project = "project-6911";
1124       String zone = "zone-5246";
1125       Instance instanceResource = Instance.newBuilder().build();
1126       client.insertAsync(project, zone, instanceResource).get();
1127       Assert.fail("No exception raised");
1128     } catch (ExecutionException e) {
1129     }
1130   }
1131 
1132   @Test
listTest()1133   public void listTest() throws Exception {
1134     Instance responsesElement = Instance.newBuilder().build();
1135     InstanceList expectedResponse =
1136         InstanceList.newBuilder()
1137             .setNextPageToken("")
1138             .addAllItems(Arrays.asList(responsesElement))
1139             .build();
1140     mockService.addResponse(expectedResponse);
1141 
1142     String project = "project-6911";
1143     String zone = "zone-5246";
1144 
1145     ListPagedResponse pagedListResponse = client.list(project, zone);
1146 
1147     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1148 
1149     Assert.assertEquals(1, resources.size());
1150     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
1151 
1152     List<String> actualRequests = mockService.getRequestPaths();
1153     Assert.assertEquals(1, actualRequests.size());
1154 
1155     String apiClientHeaderKey =
1156         mockService
1157             .getRequestHeaders()
1158             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1159             .iterator()
1160             .next();
1161     Assert.assertTrue(
1162         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1163             .matcher(apiClientHeaderKey)
1164             .matches());
1165   }
1166 
1167   @Test
listExceptionTest()1168   public void listExceptionTest() throws Exception {
1169     ApiException exception =
1170         ApiExceptionFactory.createException(
1171             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1172     mockService.addException(exception);
1173 
1174     try {
1175       String project = "project-6911";
1176       String zone = "zone-5246";
1177       client.list(project, zone);
1178       Assert.fail("No exception raised");
1179     } catch (InvalidArgumentException e) {
1180       // Expected exception.
1181     }
1182   }
1183 
1184   @Test
listReferrersTest()1185   public void listReferrersTest() throws Exception {
1186     Reference responsesElement = Reference.newBuilder().build();
1187     InstanceListReferrers expectedResponse =
1188         InstanceListReferrers.newBuilder()
1189             .setNextPageToken("")
1190             .addAllItems(Arrays.asList(responsesElement))
1191             .build();
1192     mockService.addResponse(expectedResponse);
1193 
1194     String project = "project-6911";
1195     String zone = "zone-5246";
1196     String instance = "instance-7525";
1197 
1198     ListReferrersPagedResponse pagedListResponse = client.listReferrers(project, zone, instance);
1199 
1200     List<Reference> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1201 
1202     Assert.assertEquals(1, resources.size());
1203     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
1204 
1205     List<String> actualRequests = mockService.getRequestPaths();
1206     Assert.assertEquals(1, actualRequests.size());
1207 
1208     String apiClientHeaderKey =
1209         mockService
1210             .getRequestHeaders()
1211             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1212             .iterator()
1213             .next();
1214     Assert.assertTrue(
1215         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1216             .matcher(apiClientHeaderKey)
1217             .matches());
1218   }
1219 
1220   @Test
listReferrersExceptionTest()1221   public void listReferrersExceptionTest() throws Exception {
1222     ApiException exception =
1223         ApiExceptionFactory.createException(
1224             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1225     mockService.addException(exception);
1226 
1227     try {
1228       String project = "project-6911";
1229       String zone = "zone-5246";
1230       String instance = "instance-7525";
1231       client.listReferrers(project, zone, instance);
1232       Assert.fail("No exception raised");
1233     } catch (InvalidArgumentException e) {
1234       // Expected exception.
1235     }
1236   }
1237 
1238   @Test
removeResourcePoliciesTest()1239   public void removeResourcePoliciesTest() throws Exception {
1240     Operation expectedResponse =
1241         Operation.newBuilder()
1242             .setClientOperationId("clientOperationId-1230366697")
1243             .setCreationTimestamp("creationTimestamp-370203401")
1244             .setDescription("description-1724546052")
1245             .setEndTime("endTime-1607243192")
1246             .setError(Error.newBuilder().build())
1247             .setHttpErrorMessage("httpErrorMessage1577303431")
1248             .setHttpErrorStatusCode(0)
1249             .setId(3355)
1250             .setInsertTime("insertTime966165798")
1251             .setKind("kind3292052")
1252             .setName("name3373707")
1253             .setOperationGroupId("operationGroupId1716161683")
1254             .setOperationType("operationType91999553")
1255             .setProgress(-1001078227)
1256             .setRegion("region-934795532")
1257             .setSelfLink("selfLink1191800166")
1258             .setStartTime("startTime-2129294769")
1259             .setStatus(Status.DONE)
1260             .setStatusMessage("statusMessage-958704715")
1261             .setTargetId(-815576439)
1262             .setTargetLink("targetLink486368555")
1263             .setUser("user3599307")
1264             .addAllWarnings(new ArrayList<Warnings>())
1265             .setZone("zone3744684")
1266             .build();
1267     mockService.addResponse(expectedResponse);
1268 
1269     String project = "project-6911";
1270     String zone = "zone-5246";
1271     String instance = "instance-7525";
1272     InstancesRemoveResourcePoliciesRequest instancesRemoveResourcePoliciesRequestResource =
1273         InstancesRemoveResourcePoliciesRequest.newBuilder().build();
1274 
1275     Operation actualResponse =
1276         client
1277             .removeResourcePoliciesAsync(
1278                 project, zone, instance, instancesRemoveResourcePoliciesRequestResource)
1279             .get();
1280     Assert.assertEquals(expectedResponse, actualResponse);
1281 
1282     List<String> actualRequests = mockService.getRequestPaths();
1283     Assert.assertEquals(1, actualRequests.size());
1284 
1285     String apiClientHeaderKey =
1286         mockService
1287             .getRequestHeaders()
1288             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1289             .iterator()
1290             .next();
1291     Assert.assertTrue(
1292         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1293             .matcher(apiClientHeaderKey)
1294             .matches());
1295   }
1296 
1297   @Test
removeResourcePoliciesExceptionTest()1298   public void removeResourcePoliciesExceptionTest() throws Exception {
1299     ApiException exception =
1300         ApiExceptionFactory.createException(
1301             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1302     mockService.addException(exception);
1303 
1304     try {
1305       String project = "project-6911";
1306       String zone = "zone-5246";
1307       String instance = "instance-7525";
1308       InstancesRemoveResourcePoliciesRequest instancesRemoveResourcePoliciesRequestResource =
1309           InstancesRemoveResourcePoliciesRequest.newBuilder().build();
1310       client
1311           .removeResourcePoliciesAsync(
1312               project, zone, instance, instancesRemoveResourcePoliciesRequestResource)
1313           .get();
1314       Assert.fail("No exception raised");
1315     } catch (ExecutionException e) {
1316     }
1317   }
1318 
1319   @Test
resetTest()1320   public void resetTest() throws Exception {
1321     Operation expectedResponse =
1322         Operation.newBuilder()
1323             .setClientOperationId("clientOperationId-1230366697")
1324             .setCreationTimestamp("creationTimestamp-370203401")
1325             .setDescription("description-1724546052")
1326             .setEndTime("endTime-1607243192")
1327             .setError(Error.newBuilder().build())
1328             .setHttpErrorMessage("httpErrorMessage1577303431")
1329             .setHttpErrorStatusCode(0)
1330             .setId(3355)
1331             .setInsertTime("insertTime966165798")
1332             .setKind("kind3292052")
1333             .setName("name3373707")
1334             .setOperationGroupId("operationGroupId1716161683")
1335             .setOperationType("operationType91999553")
1336             .setProgress(-1001078227)
1337             .setRegion("region-934795532")
1338             .setSelfLink("selfLink1191800166")
1339             .setStartTime("startTime-2129294769")
1340             .setStatus(Status.DONE)
1341             .setStatusMessage("statusMessage-958704715")
1342             .setTargetId(-815576439)
1343             .setTargetLink("targetLink486368555")
1344             .setUser("user3599307")
1345             .addAllWarnings(new ArrayList<Warnings>())
1346             .setZone("zone3744684")
1347             .build();
1348     mockService.addResponse(expectedResponse);
1349 
1350     String project = "project-6911";
1351     String zone = "zone-5246";
1352     String instance = "instance-7525";
1353 
1354     Operation actualResponse = client.resetAsync(project, zone, instance).get();
1355     Assert.assertEquals(expectedResponse, actualResponse);
1356 
1357     List<String> actualRequests = mockService.getRequestPaths();
1358     Assert.assertEquals(1, actualRequests.size());
1359 
1360     String apiClientHeaderKey =
1361         mockService
1362             .getRequestHeaders()
1363             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1364             .iterator()
1365             .next();
1366     Assert.assertTrue(
1367         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1368             .matcher(apiClientHeaderKey)
1369             .matches());
1370   }
1371 
1372   @Test
resetExceptionTest()1373   public void resetExceptionTest() throws Exception {
1374     ApiException exception =
1375         ApiExceptionFactory.createException(
1376             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1377     mockService.addException(exception);
1378 
1379     try {
1380       String project = "project-6911";
1381       String zone = "zone-5246";
1382       String instance = "instance-7525";
1383       client.resetAsync(project, zone, instance).get();
1384       Assert.fail("No exception raised");
1385     } catch (ExecutionException e) {
1386     }
1387   }
1388 
1389   @Test
resumeTest()1390   public void resumeTest() throws Exception {
1391     Operation expectedResponse =
1392         Operation.newBuilder()
1393             .setClientOperationId("clientOperationId-1230366697")
1394             .setCreationTimestamp("creationTimestamp-370203401")
1395             .setDescription("description-1724546052")
1396             .setEndTime("endTime-1607243192")
1397             .setError(Error.newBuilder().build())
1398             .setHttpErrorMessage("httpErrorMessage1577303431")
1399             .setHttpErrorStatusCode(0)
1400             .setId(3355)
1401             .setInsertTime("insertTime966165798")
1402             .setKind("kind3292052")
1403             .setName("name3373707")
1404             .setOperationGroupId("operationGroupId1716161683")
1405             .setOperationType("operationType91999553")
1406             .setProgress(-1001078227)
1407             .setRegion("region-934795532")
1408             .setSelfLink("selfLink1191800166")
1409             .setStartTime("startTime-2129294769")
1410             .setStatus(Status.DONE)
1411             .setStatusMessage("statusMessage-958704715")
1412             .setTargetId(-815576439)
1413             .setTargetLink("targetLink486368555")
1414             .setUser("user3599307")
1415             .addAllWarnings(new ArrayList<Warnings>())
1416             .setZone("zone3744684")
1417             .build();
1418     mockService.addResponse(expectedResponse);
1419 
1420     String project = "project-6911";
1421     String zone = "zone-5246";
1422     String instance = "instance-7525";
1423 
1424     Operation actualResponse = client.resumeAsync(project, zone, instance).get();
1425     Assert.assertEquals(expectedResponse, actualResponse);
1426 
1427     List<String> actualRequests = mockService.getRequestPaths();
1428     Assert.assertEquals(1, actualRequests.size());
1429 
1430     String apiClientHeaderKey =
1431         mockService
1432             .getRequestHeaders()
1433             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1434             .iterator()
1435             .next();
1436     Assert.assertTrue(
1437         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1438             .matcher(apiClientHeaderKey)
1439             .matches());
1440   }
1441 
1442   @Test
resumeExceptionTest()1443   public void resumeExceptionTest() throws Exception {
1444     ApiException exception =
1445         ApiExceptionFactory.createException(
1446             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1447     mockService.addException(exception);
1448 
1449     try {
1450       String project = "project-6911";
1451       String zone = "zone-5246";
1452       String instance = "instance-7525";
1453       client.resumeAsync(project, zone, instance).get();
1454       Assert.fail("No exception raised");
1455     } catch (ExecutionException e) {
1456     }
1457   }
1458 
1459   @Test
sendDiagnosticInterruptTest()1460   public void sendDiagnosticInterruptTest() throws Exception {
1461     SendDiagnosticInterruptInstanceResponse expectedResponse =
1462         SendDiagnosticInterruptInstanceResponse.newBuilder().build();
1463     mockService.addResponse(expectedResponse);
1464 
1465     String project = "project-6911";
1466     String zone = "zone-5246";
1467     String instance = "instance-7525";
1468 
1469     SendDiagnosticInterruptInstanceResponse actualResponse =
1470         client.sendDiagnosticInterrupt(project, zone, instance);
1471     Assert.assertEquals(expectedResponse, actualResponse);
1472 
1473     List<String> actualRequests = mockService.getRequestPaths();
1474     Assert.assertEquals(1, actualRequests.size());
1475 
1476     String apiClientHeaderKey =
1477         mockService
1478             .getRequestHeaders()
1479             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1480             .iterator()
1481             .next();
1482     Assert.assertTrue(
1483         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1484             .matcher(apiClientHeaderKey)
1485             .matches());
1486   }
1487 
1488   @Test
sendDiagnosticInterruptExceptionTest()1489   public void sendDiagnosticInterruptExceptionTest() throws Exception {
1490     ApiException exception =
1491         ApiExceptionFactory.createException(
1492             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1493     mockService.addException(exception);
1494 
1495     try {
1496       String project = "project-6911";
1497       String zone = "zone-5246";
1498       String instance = "instance-7525";
1499       client.sendDiagnosticInterrupt(project, zone, instance);
1500       Assert.fail("No exception raised");
1501     } catch (InvalidArgumentException e) {
1502       // Expected exception.
1503     }
1504   }
1505 
1506   @Test
setDeletionProtectionTest()1507   public void setDeletionProtectionTest() throws Exception {
1508     Operation expectedResponse =
1509         Operation.newBuilder()
1510             .setClientOperationId("clientOperationId-1230366697")
1511             .setCreationTimestamp("creationTimestamp-370203401")
1512             .setDescription("description-1724546052")
1513             .setEndTime("endTime-1607243192")
1514             .setError(Error.newBuilder().build())
1515             .setHttpErrorMessage("httpErrorMessage1577303431")
1516             .setHttpErrorStatusCode(0)
1517             .setId(3355)
1518             .setInsertTime("insertTime966165798")
1519             .setKind("kind3292052")
1520             .setName("name3373707")
1521             .setOperationGroupId("operationGroupId1716161683")
1522             .setOperationType("operationType91999553")
1523             .setProgress(-1001078227)
1524             .setRegion("region-934795532")
1525             .setSelfLink("selfLink1191800166")
1526             .setStartTime("startTime-2129294769")
1527             .setStatus(Status.DONE)
1528             .setStatusMessage("statusMessage-958704715")
1529             .setTargetId(-815576439)
1530             .setTargetLink("targetLink486368555")
1531             .setUser("user3599307")
1532             .addAllWarnings(new ArrayList<Warnings>())
1533             .setZone("zone3744684")
1534             .build();
1535     mockService.addResponse(expectedResponse);
1536 
1537     String project = "project-6911";
1538     String zone = "zone-5246";
1539     String resource = "resource-756";
1540 
1541     Operation actualResponse = client.setDeletionProtectionAsync(project, zone, resource).get();
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
setDeletionProtectionExceptionTest()1560   public void setDeletionProtectionExceptionTest() 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 project = "project-6911";
1568       String zone = "zone-5246";
1569       String resource = "resource-756";
1570       client.setDeletionProtectionAsync(project, zone, resource).get();
1571       Assert.fail("No exception raised");
1572     } catch (ExecutionException e) {
1573     }
1574   }
1575 
1576   @Test
setDiskAutoDeleteTest()1577   public void setDiskAutoDeleteTest() throws Exception {
1578     Operation expectedResponse =
1579         Operation.newBuilder()
1580             .setClientOperationId("clientOperationId-1230366697")
1581             .setCreationTimestamp("creationTimestamp-370203401")
1582             .setDescription("description-1724546052")
1583             .setEndTime("endTime-1607243192")
1584             .setError(Error.newBuilder().build())
1585             .setHttpErrorMessage("httpErrorMessage1577303431")
1586             .setHttpErrorStatusCode(0)
1587             .setId(3355)
1588             .setInsertTime("insertTime966165798")
1589             .setKind("kind3292052")
1590             .setName("name3373707")
1591             .setOperationGroupId("operationGroupId1716161683")
1592             .setOperationType("operationType91999553")
1593             .setProgress(-1001078227)
1594             .setRegion("region-934795532")
1595             .setSelfLink("selfLink1191800166")
1596             .setStartTime("startTime-2129294769")
1597             .setStatus(Status.DONE)
1598             .setStatusMessage("statusMessage-958704715")
1599             .setTargetId(-815576439)
1600             .setTargetLink("targetLink486368555")
1601             .setUser("user3599307")
1602             .addAllWarnings(new ArrayList<Warnings>())
1603             .setZone("zone3744684")
1604             .build();
1605     mockService.addResponse(expectedResponse);
1606 
1607     String project = "project-6911";
1608     String zone = "zone-5246";
1609     String instance = "instance-7525";
1610     boolean autoDelete = true;
1611     String deviceName = "deviceName780988929";
1612 
1613     Operation actualResponse =
1614         client.setDiskAutoDeleteAsync(project, zone, instance, autoDelete, deviceName).get();
1615     Assert.assertEquals(expectedResponse, actualResponse);
1616 
1617     List<String> actualRequests = mockService.getRequestPaths();
1618     Assert.assertEquals(1, actualRequests.size());
1619 
1620     String apiClientHeaderKey =
1621         mockService
1622             .getRequestHeaders()
1623             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1624             .iterator()
1625             .next();
1626     Assert.assertTrue(
1627         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1628             .matcher(apiClientHeaderKey)
1629             .matches());
1630   }
1631 
1632   @Test
setDiskAutoDeleteExceptionTest()1633   public void setDiskAutoDeleteExceptionTest() throws Exception {
1634     ApiException exception =
1635         ApiExceptionFactory.createException(
1636             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1637     mockService.addException(exception);
1638 
1639     try {
1640       String project = "project-6911";
1641       String zone = "zone-5246";
1642       String instance = "instance-7525";
1643       boolean autoDelete = true;
1644       String deviceName = "deviceName780988929";
1645       client.setDiskAutoDeleteAsync(project, zone, instance, autoDelete, deviceName).get();
1646       Assert.fail("No exception raised");
1647     } catch (ExecutionException e) {
1648     }
1649   }
1650 
1651   @Test
setIamPolicyTest()1652   public void setIamPolicyTest() throws Exception {
1653     Policy expectedResponse =
1654         Policy.newBuilder()
1655             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1656             .addAllBindings(new ArrayList<Binding>())
1657             .setEtag("etag3123477")
1658             .setIamOwned(true)
1659             .addAllRules(new ArrayList<Rule>())
1660             .setVersion(351608024)
1661             .build();
1662     mockService.addResponse(expectedResponse);
1663 
1664     String project = "project-6911";
1665     String zone = "zone-5246";
1666     String resource = "resource-756";
1667     ZoneSetPolicyRequest zoneSetPolicyRequestResource = ZoneSetPolicyRequest.newBuilder().build();
1668 
1669     Policy actualResponse =
1670         client.setIamPolicy(project, zone, resource, zoneSetPolicyRequestResource);
1671     Assert.assertEquals(expectedResponse, actualResponse);
1672 
1673     List<String> actualRequests = mockService.getRequestPaths();
1674     Assert.assertEquals(1, actualRequests.size());
1675 
1676     String apiClientHeaderKey =
1677         mockService
1678             .getRequestHeaders()
1679             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1680             .iterator()
1681             .next();
1682     Assert.assertTrue(
1683         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1684             .matcher(apiClientHeaderKey)
1685             .matches());
1686   }
1687 
1688   @Test
setIamPolicyExceptionTest()1689   public void setIamPolicyExceptionTest() throws Exception {
1690     ApiException exception =
1691         ApiExceptionFactory.createException(
1692             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1693     mockService.addException(exception);
1694 
1695     try {
1696       String project = "project-6911";
1697       String zone = "zone-5246";
1698       String resource = "resource-756";
1699       ZoneSetPolicyRequest zoneSetPolicyRequestResource = ZoneSetPolicyRequest.newBuilder().build();
1700       client.setIamPolicy(project, zone, resource, zoneSetPolicyRequestResource);
1701       Assert.fail("No exception raised");
1702     } catch (InvalidArgumentException e) {
1703       // Expected exception.
1704     }
1705   }
1706 
1707   @Test
setLabelsTest()1708   public void setLabelsTest() throws Exception {
1709     Operation expectedResponse =
1710         Operation.newBuilder()
1711             .setClientOperationId("clientOperationId-1230366697")
1712             .setCreationTimestamp("creationTimestamp-370203401")
1713             .setDescription("description-1724546052")
1714             .setEndTime("endTime-1607243192")
1715             .setError(Error.newBuilder().build())
1716             .setHttpErrorMessage("httpErrorMessage1577303431")
1717             .setHttpErrorStatusCode(0)
1718             .setId(3355)
1719             .setInsertTime("insertTime966165798")
1720             .setKind("kind3292052")
1721             .setName("name3373707")
1722             .setOperationGroupId("operationGroupId1716161683")
1723             .setOperationType("operationType91999553")
1724             .setProgress(-1001078227)
1725             .setRegion("region-934795532")
1726             .setSelfLink("selfLink1191800166")
1727             .setStartTime("startTime-2129294769")
1728             .setStatus(Status.DONE)
1729             .setStatusMessage("statusMessage-958704715")
1730             .setTargetId(-815576439)
1731             .setTargetLink("targetLink486368555")
1732             .setUser("user3599307")
1733             .addAllWarnings(new ArrayList<Warnings>())
1734             .setZone("zone3744684")
1735             .build();
1736     mockService.addResponse(expectedResponse);
1737 
1738     String project = "project-6911";
1739     String zone = "zone-5246";
1740     String instance = "instance-7525";
1741     InstancesSetLabelsRequest instancesSetLabelsRequestResource =
1742         InstancesSetLabelsRequest.newBuilder().build();
1743 
1744     Operation actualResponse =
1745         client.setLabelsAsync(project, zone, instance, instancesSetLabelsRequestResource).get();
1746     Assert.assertEquals(expectedResponse, actualResponse);
1747 
1748     List<String> actualRequests = mockService.getRequestPaths();
1749     Assert.assertEquals(1, actualRequests.size());
1750 
1751     String apiClientHeaderKey =
1752         mockService
1753             .getRequestHeaders()
1754             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1755             .iterator()
1756             .next();
1757     Assert.assertTrue(
1758         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1759             .matcher(apiClientHeaderKey)
1760             .matches());
1761   }
1762 
1763   @Test
setLabelsExceptionTest()1764   public void setLabelsExceptionTest() throws Exception {
1765     ApiException exception =
1766         ApiExceptionFactory.createException(
1767             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1768     mockService.addException(exception);
1769 
1770     try {
1771       String project = "project-6911";
1772       String zone = "zone-5246";
1773       String instance = "instance-7525";
1774       InstancesSetLabelsRequest instancesSetLabelsRequestResource =
1775           InstancesSetLabelsRequest.newBuilder().build();
1776       client.setLabelsAsync(project, zone, instance, instancesSetLabelsRequestResource).get();
1777       Assert.fail("No exception raised");
1778     } catch (ExecutionException e) {
1779     }
1780   }
1781 
1782   @Test
setMachineResourcesTest()1783   public void setMachineResourcesTest() throws Exception {
1784     Operation expectedResponse =
1785         Operation.newBuilder()
1786             .setClientOperationId("clientOperationId-1230366697")
1787             .setCreationTimestamp("creationTimestamp-370203401")
1788             .setDescription("description-1724546052")
1789             .setEndTime("endTime-1607243192")
1790             .setError(Error.newBuilder().build())
1791             .setHttpErrorMessage("httpErrorMessage1577303431")
1792             .setHttpErrorStatusCode(0)
1793             .setId(3355)
1794             .setInsertTime("insertTime966165798")
1795             .setKind("kind3292052")
1796             .setName("name3373707")
1797             .setOperationGroupId("operationGroupId1716161683")
1798             .setOperationType("operationType91999553")
1799             .setProgress(-1001078227)
1800             .setRegion("region-934795532")
1801             .setSelfLink("selfLink1191800166")
1802             .setStartTime("startTime-2129294769")
1803             .setStatus(Status.DONE)
1804             .setStatusMessage("statusMessage-958704715")
1805             .setTargetId(-815576439)
1806             .setTargetLink("targetLink486368555")
1807             .setUser("user3599307")
1808             .addAllWarnings(new ArrayList<Warnings>())
1809             .setZone("zone3744684")
1810             .build();
1811     mockService.addResponse(expectedResponse);
1812 
1813     String project = "project-6911";
1814     String zone = "zone-5246";
1815     String instance = "instance-7525";
1816     InstancesSetMachineResourcesRequest instancesSetMachineResourcesRequestResource =
1817         InstancesSetMachineResourcesRequest.newBuilder().build();
1818 
1819     Operation actualResponse =
1820         client
1821             .setMachineResourcesAsync(
1822                 project, zone, instance, instancesSetMachineResourcesRequestResource)
1823             .get();
1824     Assert.assertEquals(expectedResponse, actualResponse);
1825 
1826     List<String> actualRequests = mockService.getRequestPaths();
1827     Assert.assertEquals(1, actualRequests.size());
1828 
1829     String apiClientHeaderKey =
1830         mockService
1831             .getRequestHeaders()
1832             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1833             .iterator()
1834             .next();
1835     Assert.assertTrue(
1836         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1837             .matcher(apiClientHeaderKey)
1838             .matches());
1839   }
1840 
1841   @Test
setMachineResourcesExceptionTest()1842   public void setMachineResourcesExceptionTest() throws Exception {
1843     ApiException exception =
1844         ApiExceptionFactory.createException(
1845             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1846     mockService.addException(exception);
1847 
1848     try {
1849       String project = "project-6911";
1850       String zone = "zone-5246";
1851       String instance = "instance-7525";
1852       InstancesSetMachineResourcesRequest instancesSetMachineResourcesRequestResource =
1853           InstancesSetMachineResourcesRequest.newBuilder().build();
1854       client
1855           .setMachineResourcesAsync(
1856               project, zone, instance, instancesSetMachineResourcesRequestResource)
1857           .get();
1858       Assert.fail("No exception raised");
1859     } catch (ExecutionException e) {
1860     }
1861   }
1862 
1863   @Test
setMachineTypeTest()1864   public void setMachineTypeTest() throws Exception {
1865     Operation expectedResponse =
1866         Operation.newBuilder()
1867             .setClientOperationId("clientOperationId-1230366697")
1868             .setCreationTimestamp("creationTimestamp-370203401")
1869             .setDescription("description-1724546052")
1870             .setEndTime("endTime-1607243192")
1871             .setError(Error.newBuilder().build())
1872             .setHttpErrorMessage("httpErrorMessage1577303431")
1873             .setHttpErrorStatusCode(0)
1874             .setId(3355)
1875             .setInsertTime("insertTime966165798")
1876             .setKind("kind3292052")
1877             .setName("name3373707")
1878             .setOperationGroupId("operationGroupId1716161683")
1879             .setOperationType("operationType91999553")
1880             .setProgress(-1001078227)
1881             .setRegion("region-934795532")
1882             .setSelfLink("selfLink1191800166")
1883             .setStartTime("startTime-2129294769")
1884             .setStatus(Status.DONE)
1885             .setStatusMessage("statusMessage-958704715")
1886             .setTargetId(-815576439)
1887             .setTargetLink("targetLink486368555")
1888             .setUser("user3599307")
1889             .addAllWarnings(new ArrayList<Warnings>())
1890             .setZone("zone3744684")
1891             .build();
1892     mockService.addResponse(expectedResponse);
1893 
1894     String project = "project-6911";
1895     String zone = "zone-5246";
1896     String instance = "instance-7525";
1897     InstancesSetMachineTypeRequest instancesSetMachineTypeRequestResource =
1898         InstancesSetMachineTypeRequest.newBuilder().build();
1899 
1900     Operation actualResponse =
1901         client
1902             .setMachineTypeAsync(project, zone, instance, instancesSetMachineTypeRequestResource)
1903             .get();
1904     Assert.assertEquals(expectedResponse, actualResponse);
1905 
1906     List<String> actualRequests = mockService.getRequestPaths();
1907     Assert.assertEquals(1, actualRequests.size());
1908 
1909     String apiClientHeaderKey =
1910         mockService
1911             .getRequestHeaders()
1912             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1913             .iterator()
1914             .next();
1915     Assert.assertTrue(
1916         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1917             .matcher(apiClientHeaderKey)
1918             .matches());
1919   }
1920 
1921   @Test
setMachineTypeExceptionTest()1922   public void setMachineTypeExceptionTest() throws Exception {
1923     ApiException exception =
1924         ApiExceptionFactory.createException(
1925             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1926     mockService.addException(exception);
1927 
1928     try {
1929       String project = "project-6911";
1930       String zone = "zone-5246";
1931       String instance = "instance-7525";
1932       InstancesSetMachineTypeRequest instancesSetMachineTypeRequestResource =
1933           InstancesSetMachineTypeRequest.newBuilder().build();
1934       client
1935           .setMachineTypeAsync(project, zone, instance, instancesSetMachineTypeRequestResource)
1936           .get();
1937       Assert.fail("No exception raised");
1938     } catch (ExecutionException e) {
1939     }
1940   }
1941 
1942   @Test
setMetadataTest()1943   public void setMetadataTest() throws Exception {
1944     Operation expectedResponse =
1945         Operation.newBuilder()
1946             .setClientOperationId("clientOperationId-1230366697")
1947             .setCreationTimestamp("creationTimestamp-370203401")
1948             .setDescription("description-1724546052")
1949             .setEndTime("endTime-1607243192")
1950             .setError(Error.newBuilder().build())
1951             .setHttpErrorMessage("httpErrorMessage1577303431")
1952             .setHttpErrorStatusCode(0)
1953             .setId(3355)
1954             .setInsertTime("insertTime966165798")
1955             .setKind("kind3292052")
1956             .setName("name3373707")
1957             .setOperationGroupId("operationGroupId1716161683")
1958             .setOperationType("operationType91999553")
1959             .setProgress(-1001078227)
1960             .setRegion("region-934795532")
1961             .setSelfLink("selfLink1191800166")
1962             .setStartTime("startTime-2129294769")
1963             .setStatus(Status.DONE)
1964             .setStatusMessage("statusMessage-958704715")
1965             .setTargetId(-815576439)
1966             .setTargetLink("targetLink486368555")
1967             .setUser("user3599307")
1968             .addAllWarnings(new ArrayList<Warnings>())
1969             .setZone("zone3744684")
1970             .build();
1971     mockService.addResponse(expectedResponse);
1972 
1973     String project = "project-6911";
1974     String zone = "zone-5246";
1975     String instance = "instance-7525";
1976     Metadata metadataResource = Metadata.newBuilder().build();
1977 
1978     Operation actualResponse =
1979         client.setMetadataAsync(project, zone, instance, metadataResource).get();
1980     Assert.assertEquals(expectedResponse, actualResponse);
1981 
1982     List<String> actualRequests = mockService.getRequestPaths();
1983     Assert.assertEquals(1, actualRequests.size());
1984 
1985     String apiClientHeaderKey =
1986         mockService
1987             .getRequestHeaders()
1988             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1989             .iterator()
1990             .next();
1991     Assert.assertTrue(
1992         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1993             .matcher(apiClientHeaderKey)
1994             .matches());
1995   }
1996 
1997   @Test
setMetadataExceptionTest()1998   public void setMetadataExceptionTest() throws Exception {
1999     ApiException exception =
2000         ApiExceptionFactory.createException(
2001             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2002     mockService.addException(exception);
2003 
2004     try {
2005       String project = "project-6911";
2006       String zone = "zone-5246";
2007       String instance = "instance-7525";
2008       Metadata metadataResource = Metadata.newBuilder().build();
2009       client.setMetadataAsync(project, zone, instance, metadataResource).get();
2010       Assert.fail("No exception raised");
2011     } catch (ExecutionException e) {
2012     }
2013   }
2014 
2015   @Test
setMinCpuPlatformTest()2016   public void setMinCpuPlatformTest() throws Exception {
2017     Operation expectedResponse =
2018         Operation.newBuilder()
2019             .setClientOperationId("clientOperationId-1230366697")
2020             .setCreationTimestamp("creationTimestamp-370203401")
2021             .setDescription("description-1724546052")
2022             .setEndTime("endTime-1607243192")
2023             .setError(Error.newBuilder().build())
2024             .setHttpErrorMessage("httpErrorMessage1577303431")
2025             .setHttpErrorStatusCode(0)
2026             .setId(3355)
2027             .setInsertTime("insertTime966165798")
2028             .setKind("kind3292052")
2029             .setName("name3373707")
2030             .setOperationGroupId("operationGroupId1716161683")
2031             .setOperationType("operationType91999553")
2032             .setProgress(-1001078227)
2033             .setRegion("region-934795532")
2034             .setSelfLink("selfLink1191800166")
2035             .setStartTime("startTime-2129294769")
2036             .setStatus(Status.DONE)
2037             .setStatusMessage("statusMessage-958704715")
2038             .setTargetId(-815576439)
2039             .setTargetLink("targetLink486368555")
2040             .setUser("user3599307")
2041             .addAllWarnings(new ArrayList<Warnings>())
2042             .setZone("zone3744684")
2043             .build();
2044     mockService.addResponse(expectedResponse);
2045 
2046     String project = "project-6911";
2047     String zone = "zone-5246";
2048     String instance = "instance-7525";
2049     InstancesSetMinCpuPlatformRequest instancesSetMinCpuPlatformRequestResource =
2050         InstancesSetMinCpuPlatformRequest.newBuilder().build();
2051 
2052     Operation actualResponse =
2053         client
2054             .setMinCpuPlatformAsync(
2055                 project, zone, instance, instancesSetMinCpuPlatformRequestResource)
2056             .get();
2057     Assert.assertEquals(expectedResponse, actualResponse);
2058 
2059     List<String> actualRequests = mockService.getRequestPaths();
2060     Assert.assertEquals(1, actualRequests.size());
2061 
2062     String apiClientHeaderKey =
2063         mockService
2064             .getRequestHeaders()
2065             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2066             .iterator()
2067             .next();
2068     Assert.assertTrue(
2069         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2070             .matcher(apiClientHeaderKey)
2071             .matches());
2072   }
2073 
2074   @Test
setMinCpuPlatformExceptionTest()2075   public void setMinCpuPlatformExceptionTest() throws Exception {
2076     ApiException exception =
2077         ApiExceptionFactory.createException(
2078             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2079     mockService.addException(exception);
2080 
2081     try {
2082       String project = "project-6911";
2083       String zone = "zone-5246";
2084       String instance = "instance-7525";
2085       InstancesSetMinCpuPlatformRequest instancesSetMinCpuPlatformRequestResource =
2086           InstancesSetMinCpuPlatformRequest.newBuilder().build();
2087       client
2088           .setMinCpuPlatformAsync(
2089               project, zone, instance, instancesSetMinCpuPlatformRequestResource)
2090           .get();
2091       Assert.fail("No exception raised");
2092     } catch (ExecutionException e) {
2093     }
2094   }
2095 
2096   @Test
setNameTest()2097   public void setNameTest() throws Exception {
2098     Operation expectedResponse =
2099         Operation.newBuilder()
2100             .setClientOperationId("clientOperationId-1230366697")
2101             .setCreationTimestamp("creationTimestamp-370203401")
2102             .setDescription("description-1724546052")
2103             .setEndTime("endTime-1607243192")
2104             .setError(Error.newBuilder().build())
2105             .setHttpErrorMessage("httpErrorMessage1577303431")
2106             .setHttpErrorStatusCode(0)
2107             .setId(3355)
2108             .setInsertTime("insertTime966165798")
2109             .setKind("kind3292052")
2110             .setName("name3373707")
2111             .setOperationGroupId("operationGroupId1716161683")
2112             .setOperationType("operationType91999553")
2113             .setProgress(-1001078227)
2114             .setRegion("region-934795532")
2115             .setSelfLink("selfLink1191800166")
2116             .setStartTime("startTime-2129294769")
2117             .setStatus(Status.DONE)
2118             .setStatusMessage("statusMessage-958704715")
2119             .setTargetId(-815576439)
2120             .setTargetLink("targetLink486368555")
2121             .setUser("user3599307")
2122             .addAllWarnings(new ArrayList<Warnings>())
2123             .setZone("zone3744684")
2124             .build();
2125     mockService.addResponse(expectedResponse);
2126 
2127     String project = "project-6911";
2128     String zone = "zone-5246";
2129     String instance = "instance-7525";
2130     InstancesSetNameRequest instancesSetNameRequestResource =
2131         InstancesSetNameRequest.newBuilder().build();
2132 
2133     Operation actualResponse =
2134         client.setNameAsync(project, zone, instance, instancesSetNameRequestResource).get();
2135     Assert.assertEquals(expectedResponse, actualResponse);
2136 
2137     List<String> actualRequests = mockService.getRequestPaths();
2138     Assert.assertEquals(1, actualRequests.size());
2139 
2140     String apiClientHeaderKey =
2141         mockService
2142             .getRequestHeaders()
2143             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2144             .iterator()
2145             .next();
2146     Assert.assertTrue(
2147         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2148             .matcher(apiClientHeaderKey)
2149             .matches());
2150   }
2151 
2152   @Test
setNameExceptionTest()2153   public void setNameExceptionTest() throws Exception {
2154     ApiException exception =
2155         ApiExceptionFactory.createException(
2156             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2157     mockService.addException(exception);
2158 
2159     try {
2160       String project = "project-6911";
2161       String zone = "zone-5246";
2162       String instance = "instance-7525";
2163       InstancesSetNameRequest instancesSetNameRequestResource =
2164           InstancesSetNameRequest.newBuilder().build();
2165       client.setNameAsync(project, zone, instance, instancesSetNameRequestResource).get();
2166       Assert.fail("No exception raised");
2167     } catch (ExecutionException e) {
2168     }
2169   }
2170 
2171   @Test
setSchedulingTest()2172   public void setSchedulingTest() throws Exception {
2173     Operation expectedResponse =
2174         Operation.newBuilder()
2175             .setClientOperationId("clientOperationId-1230366697")
2176             .setCreationTimestamp("creationTimestamp-370203401")
2177             .setDescription("description-1724546052")
2178             .setEndTime("endTime-1607243192")
2179             .setError(Error.newBuilder().build())
2180             .setHttpErrorMessage("httpErrorMessage1577303431")
2181             .setHttpErrorStatusCode(0)
2182             .setId(3355)
2183             .setInsertTime("insertTime966165798")
2184             .setKind("kind3292052")
2185             .setName("name3373707")
2186             .setOperationGroupId("operationGroupId1716161683")
2187             .setOperationType("operationType91999553")
2188             .setProgress(-1001078227)
2189             .setRegion("region-934795532")
2190             .setSelfLink("selfLink1191800166")
2191             .setStartTime("startTime-2129294769")
2192             .setStatus(Status.DONE)
2193             .setStatusMessage("statusMessage-958704715")
2194             .setTargetId(-815576439)
2195             .setTargetLink("targetLink486368555")
2196             .setUser("user3599307")
2197             .addAllWarnings(new ArrayList<Warnings>())
2198             .setZone("zone3744684")
2199             .build();
2200     mockService.addResponse(expectedResponse);
2201 
2202     String project = "project-6911";
2203     String zone = "zone-5246";
2204     String instance = "instance-7525";
2205     Scheduling schedulingResource = Scheduling.newBuilder().build();
2206 
2207     Operation actualResponse =
2208         client.setSchedulingAsync(project, zone, instance, schedulingResource).get();
2209     Assert.assertEquals(expectedResponse, actualResponse);
2210 
2211     List<String> actualRequests = mockService.getRequestPaths();
2212     Assert.assertEquals(1, actualRequests.size());
2213 
2214     String apiClientHeaderKey =
2215         mockService
2216             .getRequestHeaders()
2217             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2218             .iterator()
2219             .next();
2220     Assert.assertTrue(
2221         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2222             .matcher(apiClientHeaderKey)
2223             .matches());
2224   }
2225 
2226   @Test
setSchedulingExceptionTest()2227   public void setSchedulingExceptionTest() throws Exception {
2228     ApiException exception =
2229         ApiExceptionFactory.createException(
2230             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2231     mockService.addException(exception);
2232 
2233     try {
2234       String project = "project-6911";
2235       String zone = "zone-5246";
2236       String instance = "instance-7525";
2237       Scheduling schedulingResource = Scheduling.newBuilder().build();
2238       client.setSchedulingAsync(project, zone, instance, schedulingResource).get();
2239       Assert.fail("No exception raised");
2240     } catch (ExecutionException e) {
2241     }
2242   }
2243 
2244   @Test
setServiceAccountTest()2245   public void setServiceAccountTest() throws Exception {
2246     Operation expectedResponse =
2247         Operation.newBuilder()
2248             .setClientOperationId("clientOperationId-1230366697")
2249             .setCreationTimestamp("creationTimestamp-370203401")
2250             .setDescription("description-1724546052")
2251             .setEndTime("endTime-1607243192")
2252             .setError(Error.newBuilder().build())
2253             .setHttpErrorMessage("httpErrorMessage1577303431")
2254             .setHttpErrorStatusCode(0)
2255             .setId(3355)
2256             .setInsertTime("insertTime966165798")
2257             .setKind("kind3292052")
2258             .setName("name3373707")
2259             .setOperationGroupId("operationGroupId1716161683")
2260             .setOperationType("operationType91999553")
2261             .setProgress(-1001078227)
2262             .setRegion("region-934795532")
2263             .setSelfLink("selfLink1191800166")
2264             .setStartTime("startTime-2129294769")
2265             .setStatus(Status.DONE)
2266             .setStatusMessage("statusMessage-958704715")
2267             .setTargetId(-815576439)
2268             .setTargetLink("targetLink486368555")
2269             .setUser("user3599307")
2270             .addAllWarnings(new ArrayList<Warnings>())
2271             .setZone("zone3744684")
2272             .build();
2273     mockService.addResponse(expectedResponse);
2274 
2275     String project = "project-6911";
2276     String zone = "zone-5246";
2277     String instance = "instance-7525";
2278     InstancesSetServiceAccountRequest instancesSetServiceAccountRequestResource =
2279         InstancesSetServiceAccountRequest.newBuilder().build();
2280 
2281     Operation actualResponse =
2282         client
2283             .setServiceAccountAsync(
2284                 project, zone, instance, instancesSetServiceAccountRequestResource)
2285             .get();
2286     Assert.assertEquals(expectedResponse, actualResponse);
2287 
2288     List<String> actualRequests = mockService.getRequestPaths();
2289     Assert.assertEquals(1, actualRequests.size());
2290 
2291     String apiClientHeaderKey =
2292         mockService
2293             .getRequestHeaders()
2294             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2295             .iterator()
2296             .next();
2297     Assert.assertTrue(
2298         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2299             .matcher(apiClientHeaderKey)
2300             .matches());
2301   }
2302 
2303   @Test
setServiceAccountExceptionTest()2304   public void setServiceAccountExceptionTest() throws Exception {
2305     ApiException exception =
2306         ApiExceptionFactory.createException(
2307             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2308     mockService.addException(exception);
2309 
2310     try {
2311       String project = "project-6911";
2312       String zone = "zone-5246";
2313       String instance = "instance-7525";
2314       InstancesSetServiceAccountRequest instancesSetServiceAccountRequestResource =
2315           InstancesSetServiceAccountRequest.newBuilder().build();
2316       client
2317           .setServiceAccountAsync(
2318               project, zone, instance, instancesSetServiceAccountRequestResource)
2319           .get();
2320       Assert.fail("No exception raised");
2321     } catch (ExecutionException e) {
2322     }
2323   }
2324 
2325   @Test
setShieldedInstanceIntegrityPolicyTest()2326   public void setShieldedInstanceIntegrityPolicyTest() throws Exception {
2327     Operation expectedResponse =
2328         Operation.newBuilder()
2329             .setClientOperationId("clientOperationId-1230366697")
2330             .setCreationTimestamp("creationTimestamp-370203401")
2331             .setDescription("description-1724546052")
2332             .setEndTime("endTime-1607243192")
2333             .setError(Error.newBuilder().build())
2334             .setHttpErrorMessage("httpErrorMessage1577303431")
2335             .setHttpErrorStatusCode(0)
2336             .setId(3355)
2337             .setInsertTime("insertTime966165798")
2338             .setKind("kind3292052")
2339             .setName("name3373707")
2340             .setOperationGroupId("operationGroupId1716161683")
2341             .setOperationType("operationType91999553")
2342             .setProgress(-1001078227)
2343             .setRegion("region-934795532")
2344             .setSelfLink("selfLink1191800166")
2345             .setStartTime("startTime-2129294769")
2346             .setStatus(Status.DONE)
2347             .setStatusMessage("statusMessage-958704715")
2348             .setTargetId(-815576439)
2349             .setTargetLink("targetLink486368555")
2350             .setUser("user3599307")
2351             .addAllWarnings(new ArrayList<Warnings>())
2352             .setZone("zone3744684")
2353             .build();
2354     mockService.addResponse(expectedResponse);
2355 
2356     String project = "project-6911";
2357     String zone = "zone-5246";
2358     String instance = "instance-7525";
2359     ShieldedInstanceIntegrityPolicy shieldedInstanceIntegrityPolicyResource =
2360         ShieldedInstanceIntegrityPolicy.newBuilder().build();
2361 
2362     Operation actualResponse =
2363         client
2364             .setShieldedInstanceIntegrityPolicyAsync(
2365                 project, zone, instance, shieldedInstanceIntegrityPolicyResource)
2366             .get();
2367     Assert.assertEquals(expectedResponse, actualResponse);
2368 
2369     List<String> actualRequests = mockService.getRequestPaths();
2370     Assert.assertEquals(1, actualRequests.size());
2371 
2372     String apiClientHeaderKey =
2373         mockService
2374             .getRequestHeaders()
2375             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2376             .iterator()
2377             .next();
2378     Assert.assertTrue(
2379         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2380             .matcher(apiClientHeaderKey)
2381             .matches());
2382   }
2383 
2384   @Test
setShieldedInstanceIntegrityPolicyExceptionTest()2385   public void setShieldedInstanceIntegrityPolicyExceptionTest() throws Exception {
2386     ApiException exception =
2387         ApiExceptionFactory.createException(
2388             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2389     mockService.addException(exception);
2390 
2391     try {
2392       String project = "project-6911";
2393       String zone = "zone-5246";
2394       String instance = "instance-7525";
2395       ShieldedInstanceIntegrityPolicy shieldedInstanceIntegrityPolicyResource =
2396           ShieldedInstanceIntegrityPolicy.newBuilder().build();
2397       client
2398           .setShieldedInstanceIntegrityPolicyAsync(
2399               project, zone, instance, shieldedInstanceIntegrityPolicyResource)
2400           .get();
2401       Assert.fail("No exception raised");
2402     } catch (ExecutionException e) {
2403     }
2404   }
2405 
2406   @Test
setTagsTest()2407   public void setTagsTest() throws Exception {
2408     Operation expectedResponse =
2409         Operation.newBuilder()
2410             .setClientOperationId("clientOperationId-1230366697")
2411             .setCreationTimestamp("creationTimestamp-370203401")
2412             .setDescription("description-1724546052")
2413             .setEndTime("endTime-1607243192")
2414             .setError(Error.newBuilder().build())
2415             .setHttpErrorMessage("httpErrorMessage1577303431")
2416             .setHttpErrorStatusCode(0)
2417             .setId(3355)
2418             .setInsertTime("insertTime966165798")
2419             .setKind("kind3292052")
2420             .setName("name3373707")
2421             .setOperationGroupId("operationGroupId1716161683")
2422             .setOperationType("operationType91999553")
2423             .setProgress(-1001078227)
2424             .setRegion("region-934795532")
2425             .setSelfLink("selfLink1191800166")
2426             .setStartTime("startTime-2129294769")
2427             .setStatus(Status.DONE)
2428             .setStatusMessage("statusMessage-958704715")
2429             .setTargetId(-815576439)
2430             .setTargetLink("targetLink486368555")
2431             .setUser("user3599307")
2432             .addAllWarnings(new ArrayList<Warnings>())
2433             .setZone("zone3744684")
2434             .build();
2435     mockService.addResponse(expectedResponse);
2436 
2437     String project = "project-6911";
2438     String zone = "zone-5246";
2439     String instance = "instance-7525";
2440     Tags tagsResource = Tags.newBuilder().build();
2441 
2442     Operation actualResponse = client.setTagsAsync(project, zone, instance, tagsResource).get();
2443     Assert.assertEquals(expectedResponse, actualResponse);
2444 
2445     List<String> actualRequests = mockService.getRequestPaths();
2446     Assert.assertEquals(1, actualRequests.size());
2447 
2448     String apiClientHeaderKey =
2449         mockService
2450             .getRequestHeaders()
2451             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2452             .iterator()
2453             .next();
2454     Assert.assertTrue(
2455         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2456             .matcher(apiClientHeaderKey)
2457             .matches());
2458   }
2459 
2460   @Test
setTagsExceptionTest()2461   public void setTagsExceptionTest() throws Exception {
2462     ApiException exception =
2463         ApiExceptionFactory.createException(
2464             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2465     mockService.addException(exception);
2466 
2467     try {
2468       String project = "project-6911";
2469       String zone = "zone-5246";
2470       String instance = "instance-7525";
2471       Tags tagsResource = Tags.newBuilder().build();
2472       client.setTagsAsync(project, zone, instance, tagsResource).get();
2473       Assert.fail("No exception raised");
2474     } catch (ExecutionException e) {
2475     }
2476   }
2477 
2478   @Test
simulateMaintenanceEventTest()2479   public void simulateMaintenanceEventTest() throws Exception {
2480     Operation expectedResponse =
2481         Operation.newBuilder()
2482             .setClientOperationId("clientOperationId-1230366697")
2483             .setCreationTimestamp("creationTimestamp-370203401")
2484             .setDescription("description-1724546052")
2485             .setEndTime("endTime-1607243192")
2486             .setError(Error.newBuilder().build())
2487             .setHttpErrorMessage("httpErrorMessage1577303431")
2488             .setHttpErrorStatusCode(0)
2489             .setId(3355)
2490             .setInsertTime("insertTime966165798")
2491             .setKind("kind3292052")
2492             .setName("name3373707")
2493             .setOperationGroupId("operationGroupId1716161683")
2494             .setOperationType("operationType91999553")
2495             .setProgress(-1001078227)
2496             .setRegion("region-934795532")
2497             .setSelfLink("selfLink1191800166")
2498             .setStartTime("startTime-2129294769")
2499             .setStatus(Status.DONE)
2500             .setStatusMessage("statusMessage-958704715")
2501             .setTargetId(-815576439)
2502             .setTargetLink("targetLink486368555")
2503             .setUser("user3599307")
2504             .addAllWarnings(new ArrayList<Warnings>())
2505             .setZone("zone3744684")
2506             .build();
2507     mockService.addResponse(expectedResponse);
2508 
2509     String project = "project-6911";
2510     String zone = "zone-5246";
2511     String instance = "instance-7525";
2512 
2513     Operation actualResponse = client.simulateMaintenanceEventAsync(project, zone, instance).get();
2514     Assert.assertEquals(expectedResponse, actualResponse);
2515 
2516     List<String> actualRequests = mockService.getRequestPaths();
2517     Assert.assertEquals(1, actualRequests.size());
2518 
2519     String apiClientHeaderKey =
2520         mockService
2521             .getRequestHeaders()
2522             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2523             .iterator()
2524             .next();
2525     Assert.assertTrue(
2526         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2527             .matcher(apiClientHeaderKey)
2528             .matches());
2529   }
2530 
2531   @Test
simulateMaintenanceEventExceptionTest()2532   public void simulateMaintenanceEventExceptionTest() throws Exception {
2533     ApiException exception =
2534         ApiExceptionFactory.createException(
2535             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2536     mockService.addException(exception);
2537 
2538     try {
2539       String project = "project-6911";
2540       String zone = "zone-5246";
2541       String instance = "instance-7525";
2542       client.simulateMaintenanceEventAsync(project, zone, instance).get();
2543       Assert.fail("No exception raised");
2544     } catch (ExecutionException e) {
2545     }
2546   }
2547 
2548   @Test
startTest()2549   public void startTest() throws Exception {
2550     Operation expectedResponse =
2551         Operation.newBuilder()
2552             .setClientOperationId("clientOperationId-1230366697")
2553             .setCreationTimestamp("creationTimestamp-370203401")
2554             .setDescription("description-1724546052")
2555             .setEndTime("endTime-1607243192")
2556             .setError(Error.newBuilder().build())
2557             .setHttpErrorMessage("httpErrorMessage1577303431")
2558             .setHttpErrorStatusCode(0)
2559             .setId(3355)
2560             .setInsertTime("insertTime966165798")
2561             .setKind("kind3292052")
2562             .setName("name3373707")
2563             .setOperationGroupId("operationGroupId1716161683")
2564             .setOperationType("operationType91999553")
2565             .setProgress(-1001078227)
2566             .setRegion("region-934795532")
2567             .setSelfLink("selfLink1191800166")
2568             .setStartTime("startTime-2129294769")
2569             .setStatus(Status.DONE)
2570             .setStatusMessage("statusMessage-958704715")
2571             .setTargetId(-815576439)
2572             .setTargetLink("targetLink486368555")
2573             .setUser("user3599307")
2574             .addAllWarnings(new ArrayList<Warnings>())
2575             .setZone("zone3744684")
2576             .build();
2577     mockService.addResponse(expectedResponse);
2578 
2579     String project = "project-6911";
2580     String zone = "zone-5246";
2581     String instance = "instance-7525";
2582 
2583     Operation actualResponse = client.startAsync(project, zone, instance).get();
2584     Assert.assertEquals(expectedResponse, actualResponse);
2585 
2586     List<String> actualRequests = mockService.getRequestPaths();
2587     Assert.assertEquals(1, actualRequests.size());
2588 
2589     String apiClientHeaderKey =
2590         mockService
2591             .getRequestHeaders()
2592             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2593             .iterator()
2594             .next();
2595     Assert.assertTrue(
2596         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2597             .matcher(apiClientHeaderKey)
2598             .matches());
2599   }
2600 
2601   @Test
startExceptionTest()2602   public void startExceptionTest() throws Exception {
2603     ApiException exception =
2604         ApiExceptionFactory.createException(
2605             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2606     mockService.addException(exception);
2607 
2608     try {
2609       String project = "project-6911";
2610       String zone = "zone-5246";
2611       String instance = "instance-7525";
2612       client.startAsync(project, zone, instance).get();
2613       Assert.fail("No exception raised");
2614     } catch (ExecutionException e) {
2615     }
2616   }
2617 
2618   @Test
startWithEncryptionKeyTest()2619   public void startWithEncryptionKeyTest() throws Exception {
2620     Operation expectedResponse =
2621         Operation.newBuilder()
2622             .setClientOperationId("clientOperationId-1230366697")
2623             .setCreationTimestamp("creationTimestamp-370203401")
2624             .setDescription("description-1724546052")
2625             .setEndTime("endTime-1607243192")
2626             .setError(Error.newBuilder().build())
2627             .setHttpErrorMessage("httpErrorMessage1577303431")
2628             .setHttpErrorStatusCode(0)
2629             .setId(3355)
2630             .setInsertTime("insertTime966165798")
2631             .setKind("kind3292052")
2632             .setName("name3373707")
2633             .setOperationGroupId("operationGroupId1716161683")
2634             .setOperationType("operationType91999553")
2635             .setProgress(-1001078227)
2636             .setRegion("region-934795532")
2637             .setSelfLink("selfLink1191800166")
2638             .setStartTime("startTime-2129294769")
2639             .setStatus(Status.DONE)
2640             .setStatusMessage("statusMessage-958704715")
2641             .setTargetId(-815576439)
2642             .setTargetLink("targetLink486368555")
2643             .setUser("user3599307")
2644             .addAllWarnings(new ArrayList<Warnings>())
2645             .setZone("zone3744684")
2646             .build();
2647     mockService.addResponse(expectedResponse);
2648 
2649     String project = "project-6911";
2650     String zone = "zone-5246";
2651     String instance = "instance-7525";
2652     InstancesStartWithEncryptionKeyRequest instancesStartWithEncryptionKeyRequestResource =
2653         InstancesStartWithEncryptionKeyRequest.newBuilder().build();
2654 
2655     Operation actualResponse =
2656         client
2657             .startWithEncryptionKeyAsync(
2658                 project, zone, instance, instancesStartWithEncryptionKeyRequestResource)
2659             .get();
2660     Assert.assertEquals(expectedResponse, actualResponse);
2661 
2662     List<String> actualRequests = mockService.getRequestPaths();
2663     Assert.assertEquals(1, actualRequests.size());
2664 
2665     String apiClientHeaderKey =
2666         mockService
2667             .getRequestHeaders()
2668             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2669             .iterator()
2670             .next();
2671     Assert.assertTrue(
2672         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2673             .matcher(apiClientHeaderKey)
2674             .matches());
2675   }
2676 
2677   @Test
startWithEncryptionKeyExceptionTest()2678   public void startWithEncryptionKeyExceptionTest() throws Exception {
2679     ApiException exception =
2680         ApiExceptionFactory.createException(
2681             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2682     mockService.addException(exception);
2683 
2684     try {
2685       String project = "project-6911";
2686       String zone = "zone-5246";
2687       String instance = "instance-7525";
2688       InstancesStartWithEncryptionKeyRequest instancesStartWithEncryptionKeyRequestResource =
2689           InstancesStartWithEncryptionKeyRequest.newBuilder().build();
2690       client
2691           .startWithEncryptionKeyAsync(
2692               project, zone, instance, instancesStartWithEncryptionKeyRequestResource)
2693           .get();
2694       Assert.fail("No exception raised");
2695     } catch (ExecutionException e) {
2696     }
2697   }
2698 
2699   @Test
stopTest()2700   public void stopTest() throws Exception {
2701     Operation expectedResponse =
2702         Operation.newBuilder()
2703             .setClientOperationId("clientOperationId-1230366697")
2704             .setCreationTimestamp("creationTimestamp-370203401")
2705             .setDescription("description-1724546052")
2706             .setEndTime("endTime-1607243192")
2707             .setError(Error.newBuilder().build())
2708             .setHttpErrorMessage("httpErrorMessage1577303431")
2709             .setHttpErrorStatusCode(0)
2710             .setId(3355)
2711             .setInsertTime("insertTime966165798")
2712             .setKind("kind3292052")
2713             .setName("name3373707")
2714             .setOperationGroupId("operationGroupId1716161683")
2715             .setOperationType("operationType91999553")
2716             .setProgress(-1001078227)
2717             .setRegion("region-934795532")
2718             .setSelfLink("selfLink1191800166")
2719             .setStartTime("startTime-2129294769")
2720             .setStatus(Status.DONE)
2721             .setStatusMessage("statusMessage-958704715")
2722             .setTargetId(-815576439)
2723             .setTargetLink("targetLink486368555")
2724             .setUser("user3599307")
2725             .addAllWarnings(new ArrayList<Warnings>())
2726             .setZone("zone3744684")
2727             .build();
2728     mockService.addResponse(expectedResponse);
2729 
2730     String project = "project-6911";
2731     String zone = "zone-5246";
2732     String instance = "instance-7525";
2733 
2734     Operation actualResponse = client.stopAsync(project, zone, instance).get();
2735     Assert.assertEquals(expectedResponse, actualResponse);
2736 
2737     List<String> actualRequests = mockService.getRequestPaths();
2738     Assert.assertEquals(1, actualRequests.size());
2739 
2740     String apiClientHeaderKey =
2741         mockService
2742             .getRequestHeaders()
2743             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2744             .iterator()
2745             .next();
2746     Assert.assertTrue(
2747         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2748             .matcher(apiClientHeaderKey)
2749             .matches());
2750   }
2751 
2752   @Test
stopExceptionTest()2753   public void stopExceptionTest() throws Exception {
2754     ApiException exception =
2755         ApiExceptionFactory.createException(
2756             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2757     mockService.addException(exception);
2758 
2759     try {
2760       String project = "project-6911";
2761       String zone = "zone-5246";
2762       String instance = "instance-7525";
2763       client.stopAsync(project, zone, instance).get();
2764       Assert.fail("No exception raised");
2765     } catch (ExecutionException e) {
2766     }
2767   }
2768 
2769   @Test
suspendTest()2770   public void suspendTest() throws Exception {
2771     Operation expectedResponse =
2772         Operation.newBuilder()
2773             .setClientOperationId("clientOperationId-1230366697")
2774             .setCreationTimestamp("creationTimestamp-370203401")
2775             .setDescription("description-1724546052")
2776             .setEndTime("endTime-1607243192")
2777             .setError(Error.newBuilder().build())
2778             .setHttpErrorMessage("httpErrorMessage1577303431")
2779             .setHttpErrorStatusCode(0)
2780             .setId(3355)
2781             .setInsertTime("insertTime966165798")
2782             .setKind("kind3292052")
2783             .setName("name3373707")
2784             .setOperationGroupId("operationGroupId1716161683")
2785             .setOperationType("operationType91999553")
2786             .setProgress(-1001078227)
2787             .setRegion("region-934795532")
2788             .setSelfLink("selfLink1191800166")
2789             .setStartTime("startTime-2129294769")
2790             .setStatus(Status.DONE)
2791             .setStatusMessage("statusMessage-958704715")
2792             .setTargetId(-815576439)
2793             .setTargetLink("targetLink486368555")
2794             .setUser("user3599307")
2795             .addAllWarnings(new ArrayList<Warnings>())
2796             .setZone("zone3744684")
2797             .build();
2798     mockService.addResponse(expectedResponse);
2799 
2800     String project = "project-6911";
2801     String zone = "zone-5246";
2802     String instance = "instance-7525";
2803 
2804     Operation actualResponse = client.suspendAsync(project, zone, instance).get();
2805     Assert.assertEquals(expectedResponse, actualResponse);
2806 
2807     List<String> actualRequests = mockService.getRequestPaths();
2808     Assert.assertEquals(1, actualRequests.size());
2809 
2810     String apiClientHeaderKey =
2811         mockService
2812             .getRequestHeaders()
2813             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2814             .iterator()
2815             .next();
2816     Assert.assertTrue(
2817         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2818             .matcher(apiClientHeaderKey)
2819             .matches());
2820   }
2821 
2822   @Test
suspendExceptionTest()2823   public void suspendExceptionTest() throws Exception {
2824     ApiException exception =
2825         ApiExceptionFactory.createException(
2826             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2827     mockService.addException(exception);
2828 
2829     try {
2830       String project = "project-6911";
2831       String zone = "zone-5246";
2832       String instance = "instance-7525";
2833       client.suspendAsync(project, zone, instance).get();
2834       Assert.fail("No exception raised");
2835     } catch (ExecutionException e) {
2836     }
2837   }
2838 
2839   @Test
testIamPermissionsTest()2840   public void testIamPermissionsTest() throws Exception {
2841     TestPermissionsResponse expectedResponse =
2842         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
2843     mockService.addResponse(expectedResponse);
2844 
2845     String project = "project-6911";
2846     String zone = "zone-5246";
2847     String resource = "resource-756";
2848     TestPermissionsRequest testPermissionsRequestResource =
2849         TestPermissionsRequest.newBuilder().build();
2850 
2851     TestPermissionsResponse actualResponse =
2852         client.testIamPermissions(project, zone, resource, testPermissionsRequestResource);
2853     Assert.assertEquals(expectedResponse, actualResponse);
2854 
2855     List<String> actualRequests = mockService.getRequestPaths();
2856     Assert.assertEquals(1, actualRequests.size());
2857 
2858     String apiClientHeaderKey =
2859         mockService
2860             .getRequestHeaders()
2861             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2862             .iterator()
2863             .next();
2864     Assert.assertTrue(
2865         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2866             .matcher(apiClientHeaderKey)
2867             .matches());
2868   }
2869 
2870   @Test
testIamPermissionsExceptionTest()2871   public void testIamPermissionsExceptionTest() throws Exception {
2872     ApiException exception =
2873         ApiExceptionFactory.createException(
2874             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2875     mockService.addException(exception);
2876 
2877     try {
2878       String project = "project-6911";
2879       String zone = "zone-5246";
2880       String resource = "resource-756";
2881       TestPermissionsRequest testPermissionsRequestResource =
2882           TestPermissionsRequest.newBuilder().build();
2883       client.testIamPermissions(project, zone, resource, testPermissionsRequestResource);
2884       Assert.fail("No exception raised");
2885     } catch (InvalidArgumentException e) {
2886       // Expected exception.
2887     }
2888   }
2889 
2890   @Test
updateTest()2891   public void updateTest() throws Exception {
2892     Operation expectedResponse =
2893         Operation.newBuilder()
2894             .setClientOperationId("clientOperationId-1230366697")
2895             .setCreationTimestamp("creationTimestamp-370203401")
2896             .setDescription("description-1724546052")
2897             .setEndTime("endTime-1607243192")
2898             .setError(Error.newBuilder().build())
2899             .setHttpErrorMessage("httpErrorMessage1577303431")
2900             .setHttpErrorStatusCode(0)
2901             .setId(3355)
2902             .setInsertTime("insertTime966165798")
2903             .setKind("kind3292052")
2904             .setName("name3373707")
2905             .setOperationGroupId("operationGroupId1716161683")
2906             .setOperationType("operationType91999553")
2907             .setProgress(-1001078227)
2908             .setRegion("region-934795532")
2909             .setSelfLink("selfLink1191800166")
2910             .setStartTime("startTime-2129294769")
2911             .setStatus(Status.DONE)
2912             .setStatusMessage("statusMessage-958704715")
2913             .setTargetId(-815576439)
2914             .setTargetLink("targetLink486368555")
2915             .setUser("user3599307")
2916             .addAllWarnings(new ArrayList<Warnings>())
2917             .setZone("zone3744684")
2918             .build();
2919     mockService.addResponse(expectedResponse);
2920 
2921     String project = "project-6911";
2922     String zone = "zone-5246";
2923     String instance = "instance-7525";
2924     Instance instanceResource = Instance.newBuilder().build();
2925 
2926     Operation actualResponse = client.updateAsync(project, zone, instance, instanceResource).get();
2927     Assert.assertEquals(expectedResponse, actualResponse);
2928 
2929     List<String> actualRequests = mockService.getRequestPaths();
2930     Assert.assertEquals(1, actualRequests.size());
2931 
2932     String apiClientHeaderKey =
2933         mockService
2934             .getRequestHeaders()
2935             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
2936             .iterator()
2937             .next();
2938     Assert.assertTrue(
2939         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
2940             .matcher(apiClientHeaderKey)
2941             .matches());
2942   }
2943 
2944   @Test
updateExceptionTest()2945   public void updateExceptionTest() throws Exception {
2946     ApiException exception =
2947         ApiExceptionFactory.createException(
2948             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
2949     mockService.addException(exception);
2950 
2951     try {
2952       String project = "project-6911";
2953       String zone = "zone-5246";
2954       String instance = "instance-7525";
2955       Instance instanceResource = Instance.newBuilder().build();
2956       client.updateAsync(project, zone, instance, instanceResource).get();
2957       Assert.fail("No exception raised");
2958     } catch (ExecutionException e) {
2959     }
2960   }
2961 
2962   @Test
updateAccessConfigTest()2963   public void updateAccessConfigTest() throws Exception {
2964     Operation expectedResponse =
2965         Operation.newBuilder()
2966             .setClientOperationId("clientOperationId-1230366697")
2967             .setCreationTimestamp("creationTimestamp-370203401")
2968             .setDescription("description-1724546052")
2969             .setEndTime("endTime-1607243192")
2970             .setError(Error.newBuilder().build())
2971             .setHttpErrorMessage("httpErrorMessage1577303431")
2972             .setHttpErrorStatusCode(0)
2973             .setId(3355)
2974             .setInsertTime("insertTime966165798")
2975             .setKind("kind3292052")
2976             .setName("name3373707")
2977             .setOperationGroupId("operationGroupId1716161683")
2978             .setOperationType("operationType91999553")
2979             .setProgress(-1001078227)
2980             .setRegion("region-934795532")
2981             .setSelfLink("selfLink1191800166")
2982             .setStartTime("startTime-2129294769")
2983             .setStatus(Status.DONE)
2984             .setStatusMessage("statusMessage-958704715")
2985             .setTargetId(-815576439)
2986             .setTargetLink("targetLink486368555")
2987             .setUser("user3599307")
2988             .addAllWarnings(new ArrayList<Warnings>())
2989             .setZone("zone3744684")
2990             .build();
2991     mockService.addResponse(expectedResponse);
2992 
2993     String project = "project-6911";
2994     String zone = "zone-5246";
2995     String instance = "instance-7525";
2996     String networkInterface = "networkInterface-341981525";
2997     AccessConfig accessConfigResource = AccessConfig.newBuilder().build();
2998 
2999     Operation actualResponse =
3000         client
3001             .updateAccessConfigAsync(
3002                 project, zone, instance, networkInterface, accessConfigResource)
3003             .get();
3004     Assert.assertEquals(expectedResponse, actualResponse);
3005 
3006     List<String> actualRequests = mockService.getRequestPaths();
3007     Assert.assertEquals(1, actualRequests.size());
3008 
3009     String apiClientHeaderKey =
3010         mockService
3011             .getRequestHeaders()
3012             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3013             .iterator()
3014             .next();
3015     Assert.assertTrue(
3016         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3017             .matcher(apiClientHeaderKey)
3018             .matches());
3019   }
3020 
3021   @Test
updateAccessConfigExceptionTest()3022   public void updateAccessConfigExceptionTest() throws Exception {
3023     ApiException exception =
3024         ApiExceptionFactory.createException(
3025             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3026     mockService.addException(exception);
3027 
3028     try {
3029       String project = "project-6911";
3030       String zone = "zone-5246";
3031       String instance = "instance-7525";
3032       String networkInterface = "networkInterface-341981525";
3033       AccessConfig accessConfigResource = AccessConfig.newBuilder().build();
3034       client
3035           .updateAccessConfigAsync(project, zone, instance, networkInterface, accessConfigResource)
3036           .get();
3037       Assert.fail("No exception raised");
3038     } catch (ExecutionException e) {
3039     }
3040   }
3041 
3042   @Test
updateDisplayDeviceTest()3043   public void updateDisplayDeviceTest() throws Exception {
3044     Operation expectedResponse =
3045         Operation.newBuilder()
3046             .setClientOperationId("clientOperationId-1230366697")
3047             .setCreationTimestamp("creationTimestamp-370203401")
3048             .setDescription("description-1724546052")
3049             .setEndTime("endTime-1607243192")
3050             .setError(Error.newBuilder().build())
3051             .setHttpErrorMessage("httpErrorMessage1577303431")
3052             .setHttpErrorStatusCode(0)
3053             .setId(3355)
3054             .setInsertTime("insertTime966165798")
3055             .setKind("kind3292052")
3056             .setName("name3373707")
3057             .setOperationGroupId("operationGroupId1716161683")
3058             .setOperationType("operationType91999553")
3059             .setProgress(-1001078227)
3060             .setRegion("region-934795532")
3061             .setSelfLink("selfLink1191800166")
3062             .setStartTime("startTime-2129294769")
3063             .setStatus(Status.DONE)
3064             .setStatusMessage("statusMessage-958704715")
3065             .setTargetId(-815576439)
3066             .setTargetLink("targetLink486368555")
3067             .setUser("user3599307")
3068             .addAllWarnings(new ArrayList<Warnings>())
3069             .setZone("zone3744684")
3070             .build();
3071     mockService.addResponse(expectedResponse);
3072 
3073     String project = "project-6911";
3074     String zone = "zone-5246";
3075     String instance = "instance-7525";
3076     DisplayDevice displayDeviceResource = DisplayDevice.newBuilder().build();
3077 
3078     Operation actualResponse =
3079         client.updateDisplayDeviceAsync(project, zone, instance, displayDeviceResource).get();
3080     Assert.assertEquals(expectedResponse, actualResponse);
3081 
3082     List<String> actualRequests = mockService.getRequestPaths();
3083     Assert.assertEquals(1, actualRequests.size());
3084 
3085     String apiClientHeaderKey =
3086         mockService
3087             .getRequestHeaders()
3088             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3089             .iterator()
3090             .next();
3091     Assert.assertTrue(
3092         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3093             .matcher(apiClientHeaderKey)
3094             .matches());
3095   }
3096 
3097   @Test
updateDisplayDeviceExceptionTest()3098   public void updateDisplayDeviceExceptionTest() throws Exception {
3099     ApiException exception =
3100         ApiExceptionFactory.createException(
3101             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3102     mockService.addException(exception);
3103 
3104     try {
3105       String project = "project-6911";
3106       String zone = "zone-5246";
3107       String instance = "instance-7525";
3108       DisplayDevice displayDeviceResource = DisplayDevice.newBuilder().build();
3109       client.updateDisplayDeviceAsync(project, zone, instance, displayDeviceResource).get();
3110       Assert.fail("No exception raised");
3111     } catch (ExecutionException e) {
3112     }
3113   }
3114 
3115   @Test
updateNetworkInterfaceTest()3116   public void updateNetworkInterfaceTest() throws Exception {
3117     Operation expectedResponse =
3118         Operation.newBuilder()
3119             .setClientOperationId("clientOperationId-1230366697")
3120             .setCreationTimestamp("creationTimestamp-370203401")
3121             .setDescription("description-1724546052")
3122             .setEndTime("endTime-1607243192")
3123             .setError(Error.newBuilder().build())
3124             .setHttpErrorMessage("httpErrorMessage1577303431")
3125             .setHttpErrorStatusCode(0)
3126             .setId(3355)
3127             .setInsertTime("insertTime966165798")
3128             .setKind("kind3292052")
3129             .setName("name3373707")
3130             .setOperationGroupId("operationGroupId1716161683")
3131             .setOperationType("operationType91999553")
3132             .setProgress(-1001078227)
3133             .setRegion("region-934795532")
3134             .setSelfLink("selfLink1191800166")
3135             .setStartTime("startTime-2129294769")
3136             .setStatus(Status.DONE)
3137             .setStatusMessage("statusMessage-958704715")
3138             .setTargetId(-815576439)
3139             .setTargetLink("targetLink486368555")
3140             .setUser("user3599307")
3141             .addAllWarnings(new ArrayList<Warnings>())
3142             .setZone("zone3744684")
3143             .build();
3144     mockService.addResponse(expectedResponse);
3145 
3146     String project = "project-6911";
3147     String zone = "zone-5246";
3148     String instance = "instance-7525";
3149     String networkInterface = "networkInterface-341981525";
3150     NetworkInterface networkInterfaceResource = NetworkInterface.newBuilder().build();
3151 
3152     Operation actualResponse =
3153         client
3154             .updateNetworkInterfaceAsync(
3155                 project, zone, instance, networkInterface, networkInterfaceResource)
3156             .get();
3157     Assert.assertEquals(expectedResponse, actualResponse);
3158 
3159     List<String> actualRequests = mockService.getRequestPaths();
3160     Assert.assertEquals(1, actualRequests.size());
3161 
3162     String apiClientHeaderKey =
3163         mockService
3164             .getRequestHeaders()
3165             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3166             .iterator()
3167             .next();
3168     Assert.assertTrue(
3169         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3170             .matcher(apiClientHeaderKey)
3171             .matches());
3172   }
3173 
3174   @Test
updateNetworkInterfaceExceptionTest()3175   public void updateNetworkInterfaceExceptionTest() throws Exception {
3176     ApiException exception =
3177         ApiExceptionFactory.createException(
3178             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3179     mockService.addException(exception);
3180 
3181     try {
3182       String project = "project-6911";
3183       String zone = "zone-5246";
3184       String instance = "instance-7525";
3185       String networkInterface = "networkInterface-341981525";
3186       NetworkInterface networkInterfaceResource = NetworkInterface.newBuilder().build();
3187       client
3188           .updateNetworkInterfaceAsync(
3189               project, zone, instance, networkInterface, networkInterfaceResource)
3190           .get();
3191       Assert.fail("No exception raised");
3192     } catch (ExecutionException e) {
3193     }
3194   }
3195 
3196   @Test
updateShieldedInstanceConfigTest()3197   public void updateShieldedInstanceConfigTest() throws Exception {
3198     Operation expectedResponse =
3199         Operation.newBuilder()
3200             .setClientOperationId("clientOperationId-1230366697")
3201             .setCreationTimestamp("creationTimestamp-370203401")
3202             .setDescription("description-1724546052")
3203             .setEndTime("endTime-1607243192")
3204             .setError(Error.newBuilder().build())
3205             .setHttpErrorMessage("httpErrorMessage1577303431")
3206             .setHttpErrorStatusCode(0)
3207             .setId(3355)
3208             .setInsertTime("insertTime966165798")
3209             .setKind("kind3292052")
3210             .setName("name3373707")
3211             .setOperationGroupId("operationGroupId1716161683")
3212             .setOperationType("operationType91999553")
3213             .setProgress(-1001078227)
3214             .setRegion("region-934795532")
3215             .setSelfLink("selfLink1191800166")
3216             .setStartTime("startTime-2129294769")
3217             .setStatus(Status.DONE)
3218             .setStatusMessage("statusMessage-958704715")
3219             .setTargetId(-815576439)
3220             .setTargetLink("targetLink486368555")
3221             .setUser("user3599307")
3222             .addAllWarnings(new ArrayList<Warnings>())
3223             .setZone("zone3744684")
3224             .build();
3225     mockService.addResponse(expectedResponse);
3226 
3227     String project = "project-6911";
3228     String zone = "zone-5246";
3229     String instance = "instance-7525";
3230     ShieldedInstanceConfig shieldedInstanceConfigResource =
3231         ShieldedInstanceConfig.newBuilder().build();
3232 
3233     Operation actualResponse =
3234         client
3235             .updateShieldedInstanceConfigAsync(
3236                 project, zone, instance, shieldedInstanceConfigResource)
3237             .get();
3238     Assert.assertEquals(expectedResponse, actualResponse);
3239 
3240     List<String> actualRequests = mockService.getRequestPaths();
3241     Assert.assertEquals(1, actualRequests.size());
3242 
3243     String apiClientHeaderKey =
3244         mockService
3245             .getRequestHeaders()
3246             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
3247             .iterator()
3248             .next();
3249     Assert.assertTrue(
3250         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
3251             .matcher(apiClientHeaderKey)
3252             .matches());
3253   }
3254 
3255   @Test
updateShieldedInstanceConfigExceptionTest()3256   public void updateShieldedInstanceConfigExceptionTest() throws Exception {
3257     ApiException exception =
3258         ApiExceptionFactory.createException(
3259             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
3260     mockService.addException(exception);
3261 
3262     try {
3263       String project = "project-6911";
3264       String zone = "zone-5246";
3265       String instance = "instance-7525";
3266       ShieldedInstanceConfig shieldedInstanceConfigResource =
3267           ShieldedInstanceConfig.newBuilder().build();
3268       client
3269           .updateShieldedInstanceConfigAsync(
3270               project, zone, instance, shieldedInstanceConfigResource)
3271           .get();
3272       Assert.fail("No exception raised");
3273     } catch (ExecutionException e) {
3274     }
3275   }
3276 }
3277