getMap()
              .computeIfAbsent(
                  k0(),
                  k -> {
                    assertEquals(k0(), k);
                    return v0();
                  }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

                } catch (final SuggesterException e) {
                    logger.warn("Failed to generate popular words.", e);
                }

                return wordList;
            });
        } catch (final ExecutionException e) {
            logger.warn("Failed to load popular words.", e);
        }

      MoreExecutors.renamingDecorator(executor(), threadNameSupplier)
          .execute(
              () -> {
                try {
                  startUp();
                  notifyStarted();
                } catch (Throwable t) {
                  restoreInterruptIfIsInterruptedException(t);
                  notifyFailed(t);
                }
              });
    }

    @Override
    protected final void doStop() {

                break;
            } else if (id == id0) {
                try {
                    return new String(type2token, ri, len, SmbConstants.UNI_ENCODING);
                } catch (java.io.UnsupportedEncodingException uee) {
                    break;
                }
            }
            ri += len;
        }

        return null;
    }

            try {
                String version = resolveVersion(artifact, request);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

        try {
            return includeFilterCache.get(sessionId);
        } catch (final ExecutionException e) {
            throw new CrawlerSystemException(e);
        }
    }

    @Override
    public List<Pattern> getExcludeUrlPatternList(final String sessionId) {
        try {
            return excludeFilterCache.get(sessionId);
        } catch (final ExecutionException e) {
            throw new CrawlerSystemException(e);

    val secondResponseCode = AtomicInteger()
    val secondRequest = "/bar"
    val firstRequest = "/foo"
    val latch = CountDownLatch(1)
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          if (request.path == firstRequest) {
            latch.await()
          }
          return MockResponse()
        }
      }

        getUser(form).ifPresent(entity -> {
            try {
                userService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to add {}", entity, e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

    assertEquals(
        "Shouldn't catch any more events when unregistered.", expectedEvents, catcher1.getEvents());
    assertEquals("Two correct events should be delivered.", expectedEvents, catcher2.getEvents());

    assertThrows(IllegalArgumentException.class, () -> bus.unregister(catcher1));

    bus.unregister(catcher2);
    bus.post(EVENT);
    assertEquals(

                client.admin().cluster().prepareHealth().setWaitForYellowStatus().execute().actionGet(suggestSettings.getClusterTimeout());
                created = true;
            }
            return created;
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create index. index: {}", index, e);
            }