• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.gaming.v1;
18 
19 import static com.google.cloud.gaming.v1.RealmsServiceClient.ListRealmsPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.grpc.GaxGrpcProperties;
23 import com.google.api.gax.grpc.testing.LocalChannelProvider;
24 import com.google.api.gax.grpc.testing.MockGrpcService;
25 import com.google.api.gax.grpc.testing.MockServiceHelper;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.common.collect.Lists;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.FieldMask;
35 import com.google.protobuf.Timestamp;
36 import io.grpc.StatusRuntimeException;
37 import java.io.IOException;
38 import java.util.Arrays;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.UUID;
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 RealmsServiceClientTest {
53   private static MockRealmsService mockRealmsService;
54   private static MockServiceHelper mockServiceHelper;
55   private LocalChannelProvider channelProvider;
56   private RealmsServiceClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() {
60     mockRealmsService = new MockRealmsService();
61     mockServiceHelper =
62         new MockServiceHelper(
63             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockRealmsService));
64     mockServiceHelper.start();
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     mockServiceHelper.stop();
70   }
71 
72   @Before
setUp()73   public void setUp() throws IOException {
74     mockServiceHelper.reset();
75     channelProvider = mockServiceHelper.createChannelProvider();
76     RealmsServiceSettings settings =
77         RealmsServiceSettings.newBuilder()
78             .setTransportChannelProvider(channelProvider)
79             .setCredentialsProvider(NoCredentialsProvider.create())
80             .build();
81     client = RealmsServiceClient.create(settings);
82   }
83 
84   @After
tearDown()85   public void tearDown() throws Exception {
86     client.close();
87   }
88 
89   @Test
listRealmsTest()90   public void listRealmsTest() throws Exception {
91     Realm responsesElement = Realm.newBuilder().build();
92     ListRealmsResponse expectedResponse =
93         ListRealmsResponse.newBuilder()
94             .setNextPageToken("")
95             .addAllRealms(Arrays.asList(responsesElement))
96             .build();
97     mockRealmsService.addResponse(expectedResponse);
98 
99     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
100 
101     ListRealmsPagedResponse pagedListResponse = client.listRealms(parent);
102 
103     List<Realm> resources = Lists.newArrayList(pagedListResponse.iterateAll());
104 
105     Assert.assertEquals(1, resources.size());
106     Assert.assertEquals(expectedResponse.getRealmsList().get(0), resources.get(0));
107 
108     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
109     Assert.assertEquals(1, actualRequests.size());
110     ListRealmsRequest actualRequest = ((ListRealmsRequest) actualRequests.get(0));
111 
112     Assert.assertEquals(parent.toString(), actualRequest.getParent());
113     Assert.assertTrue(
114         channelProvider.isHeaderSent(
115             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
116             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
117   }
118 
119   @Test
listRealmsExceptionTest()120   public void listRealmsExceptionTest() throws Exception {
121     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
122     mockRealmsService.addException(exception);
123 
124     try {
125       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
126       client.listRealms(parent);
127       Assert.fail("No exception raised");
128     } catch (InvalidArgumentException e) {
129       // Expected exception.
130     }
131   }
132 
133   @Test
listRealmsTest2()134   public void listRealmsTest2() throws Exception {
135     Realm responsesElement = Realm.newBuilder().build();
136     ListRealmsResponse expectedResponse =
137         ListRealmsResponse.newBuilder()
138             .setNextPageToken("")
139             .addAllRealms(Arrays.asList(responsesElement))
140             .build();
141     mockRealmsService.addResponse(expectedResponse);
142 
143     String parent = "parent-995424086";
144 
145     ListRealmsPagedResponse pagedListResponse = client.listRealms(parent);
146 
147     List<Realm> resources = Lists.newArrayList(pagedListResponse.iterateAll());
148 
149     Assert.assertEquals(1, resources.size());
150     Assert.assertEquals(expectedResponse.getRealmsList().get(0), resources.get(0));
151 
152     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
153     Assert.assertEquals(1, actualRequests.size());
154     ListRealmsRequest actualRequest = ((ListRealmsRequest) actualRequests.get(0));
155 
156     Assert.assertEquals(parent, actualRequest.getParent());
157     Assert.assertTrue(
158         channelProvider.isHeaderSent(
159             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
160             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
161   }
162 
163   @Test
listRealmsExceptionTest2()164   public void listRealmsExceptionTest2() throws Exception {
165     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
166     mockRealmsService.addException(exception);
167 
168     try {
169       String parent = "parent-995424086";
170       client.listRealms(parent);
171       Assert.fail("No exception raised");
172     } catch (InvalidArgumentException e) {
173       // Expected exception.
174     }
175   }
176 
177   @Test
getRealmTest()178   public void getRealmTest() throws Exception {
179     Realm expectedResponse =
180         Realm.newBuilder()
181             .setName(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
182             .setCreateTime(Timestamp.newBuilder().build())
183             .setUpdateTime(Timestamp.newBuilder().build())
184             .putAllLabels(new HashMap<String, String>())
185             .setTimeZone("timeZone-2077180903")
186             .setEtag("etag3123477")
187             .setDescription("description-1724546052")
188             .build();
189     mockRealmsService.addResponse(expectedResponse);
190 
191     RealmName name = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
192 
193     Realm actualResponse = client.getRealm(name);
194     Assert.assertEquals(expectedResponse, actualResponse);
195 
196     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
197     Assert.assertEquals(1, actualRequests.size());
198     GetRealmRequest actualRequest = ((GetRealmRequest) actualRequests.get(0));
199 
200     Assert.assertEquals(name.toString(), actualRequest.getName());
201     Assert.assertTrue(
202         channelProvider.isHeaderSent(
203             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
204             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
205   }
206 
207   @Test
getRealmExceptionTest()208   public void getRealmExceptionTest() throws Exception {
209     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
210     mockRealmsService.addException(exception);
211 
212     try {
213       RealmName name = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
214       client.getRealm(name);
215       Assert.fail("No exception raised");
216     } catch (InvalidArgumentException e) {
217       // Expected exception.
218     }
219   }
220 
221   @Test
getRealmTest2()222   public void getRealmTest2() throws Exception {
223     Realm expectedResponse =
224         Realm.newBuilder()
225             .setName(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
226             .setCreateTime(Timestamp.newBuilder().build())
227             .setUpdateTime(Timestamp.newBuilder().build())
228             .putAllLabels(new HashMap<String, String>())
229             .setTimeZone("timeZone-2077180903")
230             .setEtag("etag3123477")
231             .setDescription("description-1724546052")
232             .build();
233     mockRealmsService.addResponse(expectedResponse);
234 
235     String name = "name3373707";
236 
237     Realm actualResponse = client.getRealm(name);
238     Assert.assertEquals(expectedResponse, actualResponse);
239 
240     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
241     Assert.assertEquals(1, actualRequests.size());
242     GetRealmRequest actualRequest = ((GetRealmRequest) actualRequests.get(0));
243 
244     Assert.assertEquals(name, actualRequest.getName());
245     Assert.assertTrue(
246         channelProvider.isHeaderSent(
247             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
248             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
249   }
250 
251   @Test
getRealmExceptionTest2()252   public void getRealmExceptionTest2() throws Exception {
253     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
254     mockRealmsService.addException(exception);
255 
256     try {
257       String name = "name3373707";
258       client.getRealm(name);
259       Assert.fail("No exception raised");
260     } catch (InvalidArgumentException e) {
261       // Expected exception.
262     }
263   }
264 
265   @Test
createRealmTest()266   public void createRealmTest() throws Exception {
267     Realm expectedResponse =
268         Realm.newBuilder()
269             .setName(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
270             .setCreateTime(Timestamp.newBuilder().build())
271             .setUpdateTime(Timestamp.newBuilder().build())
272             .putAllLabels(new HashMap<String, String>())
273             .setTimeZone("timeZone-2077180903")
274             .setEtag("etag3123477")
275             .setDescription("description-1724546052")
276             .build();
277     Operation resultOperation =
278         Operation.newBuilder()
279             .setName("createRealmTest")
280             .setDone(true)
281             .setResponse(Any.pack(expectedResponse))
282             .build();
283     mockRealmsService.addResponse(resultOperation);
284 
285     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
286     Realm realm = Realm.newBuilder().build();
287     String realmId = "realmId1080654858";
288 
289     Realm actualResponse = client.createRealmAsync(parent, realm, realmId).get();
290     Assert.assertEquals(expectedResponse, actualResponse);
291 
292     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
293     Assert.assertEquals(1, actualRequests.size());
294     CreateRealmRequest actualRequest = ((CreateRealmRequest) actualRequests.get(0));
295 
296     Assert.assertEquals(parent.toString(), actualRequest.getParent());
297     Assert.assertEquals(realm, actualRequest.getRealm());
298     Assert.assertEquals(realmId, actualRequest.getRealmId());
299     Assert.assertTrue(
300         channelProvider.isHeaderSent(
301             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
302             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
303   }
304 
305   @Test
createRealmExceptionTest()306   public void createRealmExceptionTest() throws Exception {
307     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
308     mockRealmsService.addException(exception);
309 
310     try {
311       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
312       Realm realm = Realm.newBuilder().build();
313       String realmId = "realmId1080654858";
314       client.createRealmAsync(parent, realm, realmId).get();
315       Assert.fail("No exception raised");
316     } catch (ExecutionException e) {
317       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
318       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
319       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
320     }
321   }
322 
323   @Test
createRealmTest2()324   public void createRealmTest2() throws Exception {
325     Realm expectedResponse =
326         Realm.newBuilder()
327             .setName(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
328             .setCreateTime(Timestamp.newBuilder().build())
329             .setUpdateTime(Timestamp.newBuilder().build())
330             .putAllLabels(new HashMap<String, String>())
331             .setTimeZone("timeZone-2077180903")
332             .setEtag("etag3123477")
333             .setDescription("description-1724546052")
334             .build();
335     Operation resultOperation =
336         Operation.newBuilder()
337             .setName("createRealmTest")
338             .setDone(true)
339             .setResponse(Any.pack(expectedResponse))
340             .build();
341     mockRealmsService.addResponse(resultOperation);
342 
343     String parent = "parent-995424086";
344     Realm realm = Realm.newBuilder().build();
345     String realmId = "realmId1080654858";
346 
347     Realm actualResponse = client.createRealmAsync(parent, realm, realmId).get();
348     Assert.assertEquals(expectedResponse, actualResponse);
349 
350     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
351     Assert.assertEquals(1, actualRequests.size());
352     CreateRealmRequest actualRequest = ((CreateRealmRequest) actualRequests.get(0));
353 
354     Assert.assertEquals(parent, actualRequest.getParent());
355     Assert.assertEquals(realm, actualRequest.getRealm());
356     Assert.assertEquals(realmId, actualRequest.getRealmId());
357     Assert.assertTrue(
358         channelProvider.isHeaderSent(
359             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
360             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
361   }
362 
363   @Test
createRealmExceptionTest2()364   public void createRealmExceptionTest2() throws Exception {
365     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
366     mockRealmsService.addException(exception);
367 
368     try {
369       String parent = "parent-995424086";
370       Realm realm = Realm.newBuilder().build();
371       String realmId = "realmId1080654858";
372       client.createRealmAsync(parent, realm, realmId).get();
373       Assert.fail("No exception raised");
374     } catch (ExecutionException e) {
375       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
376       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
377       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
378     }
379   }
380 
381   @Test
deleteRealmTest()382   public void deleteRealmTest() throws Exception {
383     Empty expectedResponse = Empty.newBuilder().build();
384     Operation resultOperation =
385         Operation.newBuilder()
386             .setName("deleteRealmTest")
387             .setDone(true)
388             .setResponse(Any.pack(expectedResponse))
389             .build();
390     mockRealmsService.addResponse(resultOperation);
391 
392     RealmName name = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
393 
394     client.deleteRealmAsync(name).get();
395 
396     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
397     Assert.assertEquals(1, actualRequests.size());
398     DeleteRealmRequest actualRequest = ((DeleteRealmRequest) actualRequests.get(0));
399 
400     Assert.assertEquals(name.toString(), actualRequest.getName());
401     Assert.assertTrue(
402         channelProvider.isHeaderSent(
403             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
404             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
405   }
406 
407   @Test
deleteRealmExceptionTest()408   public void deleteRealmExceptionTest() throws Exception {
409     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
410     mockRealmsService.addException(exception);
411 
412     try {
413       RealmName name = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
414       client.deleteRealmAsync(name).get();
415       Assert.fail("No exception raised");
416     } catch (ExecutionException e) {
417       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
418       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
419       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
420     }
421   }
422 
423   @Test
deleteRealmTest2()424   public void deleteRealmTest2() throws Exception {
425     Empty expectedResponse = Empty.newBuilder().build();
426     Operation resultOperation =
427         Operation.newBuilder()
428             .setName("deleteRealmTest")
429             .setDone(true)
430             .setResponse(Any.pack(expectedResponse))
431             .build();
432     mockRealmsService.addResponse(resultOperation);
433 
434     String name = "name3373707";
435 
436     client.deleteRealmAsync(name).get();
437 
438     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
439     Assert.assertEquals(1, actualRequests.size());
440     DeleteRealmRequest actualRequest = ((DeleteRealmRequest) actualRequests.get(0));
441 
442     Assert.assertEquals(name, actualRequest.getName());
443     Assert.assertTrue(
444         channelProvider.isHeaderSent(
445             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
446             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
447   }
448 
449   @Test
deleteRealmExceptionTest2()450   public void deleteRealmExceptionTest2() throws Exception {
451     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
452     mockRealmsService.addException(exception);
453 
454     try {
455       String name = "name3373707";
456       client.deleteRealmAsync(name).get();
457       Assert.fail("No exception raised");
458     } catch (ExecutionException e) {
459       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
460       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
461       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
462     }
463   }
464 
465   @Test
updateRealmTest()466   public void updateRealmTest() throws Exception {
467     Realm expectedResponse =
468         Realm.newBuilder()
469             .setName(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
470             .setCreateTime(Timestamp.newBuilder().build())
471             .setUpdateTime(Timestamp.newBuilder().build())
472             .putAllLabels(new HashMap<String, String>())
473             .setTimeZone("timeZone-2077180903")
474             .setEtag("etag3123477")
475             .setDescription("description-1724546052")
476             .build();
477     Operation resultOperation =
478         Operation.newBuilder()
479             .setName("updateRealmTest")
480             .setDone(true)
481             .setResponse(Any.pack(expectedResponse))
482             .build();
483     mockRealmsService.addResponse(resultOperation);
484 
485     Realm realm = Realm.newBuilder().build();
486     FieldMask updateMask = FieldMask.newBuilder().build();
487 
488     Realm actualResponse = client.updateRealmAsync(realm, updateMask).get();
489     Assert.assertEquals(expectedResponse, actualResponse);
490 
491     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
492     Assert.assertEquals(1, actualRequests.size());
493     UpdateRealmRequest actualRequest = ((UpdateRealmRequest) actualRequests.get(0));
494 
495     Assert.assertEquals(realm, actualRequest.getRealm());
496     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
497     Assert.assertTrue(
498         channelProvider.isHeaderSent(
499             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
500             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
501   }
502 
503   @Test
updateRealmExceptionTest()504   public void updateRealmExceptionTest() throws Exception {
505     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
506     mockRealmsService.addException(exception);
507 
508     try {
509       Realm realm = Realm.newBuilder().build();
510       FieldMask updateMask = FieldMask.newBuilder().build();
511       client.updateRealmAsync(realm, updateMask).get();
512       Assert.fail("No exception raised");
513     } catch (ExecutionException e) {
514       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
515       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
516       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
517     }
518   }
519 
520   @Test
previewRealmUpdateTest()521   public void previewRealmUpdateTest() throws Exception {
522     PreviewRealmUpdateResponse expectedResponse =
523         PreviewRealmUpdateResponse.newBuilder()
524             .setEtag("etag3123477")
525             .setTargetState(TargetState.newBuilder().build())
526             .build();
527     mockRealmsService.addResponse(expectedResponse);
528 
529     PreviewRealmUpdateRequest request =
530         PreviewRealmUpdateRequest.newBuilder()
531             .setRealm(Realm.newBuilder().build())
532             .setUpdateMask(FieldMask.newBuilder().build())
533             .setPreviewTime(Timestamp.newBuilder().build())
534             .build();
535 
536     PreviewRealmUpdateResponse actualResponse = client.previewRealmUpdate(request);
537     Assert.assertEquals(expectedResponse, actualResponse);
538 
539     List<AbstractMessage> actualRequests = mockRealmsService.getRequests();
540     Assert.assertEquals(1, actualRequests.size());
541     PreviewRealmUpdateRequest actualRequest = ((PreviewRealmUpdateRequest) actualRequests.get(0));
542 
543     Assert.assertEquals(request.getRealm(), actualRequest.getRealm());
544     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
545     Assert.assertEquals(request.getPreviewTime(), actualRequest.getPreviewTime());
546     Assert.assertTrue(
547         channelProvider.isHeaderSent(
548             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
549             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
550   }
551 
552   @Test
previewRealmUpdateExceptionTest()553   public void previewRealmUpdateExceptionTest() throws Exception {
554     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
555     mockRealmsService.addException(exception);
556 
557     try {
558       PreviewRealmUpdateRequest request =
559           PreviewRealmUpdateRequest.newBuilder()
560               .setRealm(Realm.newBuilder().build())
561               .setUpdateMask(FieldMask.newBuilder().build())
562               .setPreviewTime(Timestamp.newBuilder().build())
563               .build();
564       client.previewRealmUpdate(request);
565       Assert.fail("No exception raised");
566     } catch (InvalidArgumentException e) {
567       // Expected exception.
568     }
569   }
570 }
571