throw new AssertionError(impossible);
    } catch (InvocationTargetException e) {
      logger.log(Level.WARNING, "Exception while invoking default constructor.", e.getCause());
      return arbitraryConstantInstanceOrNull(type);
    }
  }

  private static <T> @Nullable T arbitraryConstantInstanceOrNull(Class<T> type) {
    Field[] fields = type.getDeclaredFields();

                            return this.type;
                        }
                    }
                } catch (final CIFSException e) {
                    if (!(e.getCause() instanceof UnknownHostException)) {
                        throw e;
                    }
                    log.debug("Unknown host", e);
                }
                this.type = SmbConstants.TYPE_SERVER;

            .removalListener(listener)
            .ticker(ticker)
            .build();
    cache.put(1, 1);
    ticker.advance(10, MINUTES);
    cache.invalidateAll();

    assertThat(listener.poll().getCause()).isEqualTo(RemovalCause.EXPIRED);
  }

  private void runRemovalScheduler(
      LoadingCache<String, Integer> cache,
      CountingRemovalListener<String, Integer> removalListener,

                    + "isCancelled() == true: "
                    + future,
                exception));
      }
      return new Failure(exception.getCause());
    } catch (CancellationException cancellation) {
      if (!wasCancelled) {
        return new Failure(
            new IllegalArgumentException(

    }

    @Override
    public V getUnchecked(K key) {
      try {
        return get(key);
      } catch (ExecutionException e) {
        throw new UncheckedExecutionException(e.getCause());
      }
    }

    @Override
    public V apply(K key) {
      return getUnchecked(key);
    }

    @Override

            if (logger.isInfoEnabled()) {
                final StringBuilder buf = new StringBuilder(100);
                buf.append(e.getMessage());
                if (e.getCause() != null) {
                    buf.append(e.getCause().getMessage());
                }
                logger.info(buf.toString());
            } else if (logger.isDebugEnabled()) {

            assertTrue(exception instanceof java.lang.reflect.InvocationTargetException, "Should be wrapped in InvocationTargetException");
            Throwable cause = exception.getCause();
            assertTrue(cause instanceof SMBProtocolDecodingException, "Actual cause should be SMBProtocolDecodingException");

        } catch (RuntimeException e) {
            // Unwrap IOException from RuntimeException
            if (e.getCause() instanceof IOException) {
                throw (IOException) e.getCause();
            }
            throw new IOException("Connection failed", e);
        } catch (Exception e) {
            // Handle any other exceptions from circuit breaker

                    }
                } catch (final DataStoreCrawlingException e) {
                    crawlerStatsHelper.record(keyObj, StatsAction.ACCESS_EXCEPTION);
                    final Throwable cause = e.getCause();
                    if (cause instanceof ChildUrlsException) {
                        if (maxDepth == -1 || crawlRequest.getDepth() < maxDepth) {
                            ((ChildUrlsException) cause).getChildUrlList()

              + " from "
              + invokable
              + Arrays.toString(params)
              + " for "
              + testedClass);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      if (policy.isExpectedType(cause)) {
        return;
      }
      throw new AssertionError(
          String.format(