}
    return methodsInListener;
  }

  private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz) {
    try {
      return subscriberMethodsCache.getUnchecked(clazz);
    } catch (UncheckedExecutionException e) {
      if (e.getCause() instanceof IllegalArgumentException) {
        /*
         * IllegalArgumentException is the one unchecked exception that we know is likely to happen

    // first as suppressed exceptions. We don't catch Error on the grounds that it should be allowed
    // to propagate immediately.
    Exception exception = null;
    for (BaseStream<?, ?> stream : toClose) {
      try {
        stream.close();
      } catch (Exception e) { // sneaky checked exception
        if (exception == null) {
          exception = e;

                        }
                    } else {
                        queue.add(source);
                    }
                }
                exception = null;
                break;
            } catch (final Exception e) {
                exception = new SuggesterException(e);
                scrollId = null;
            }
        }

        docCount.getAndAdd(queue.size());

                            encrypted.add(encryptedData);
                        }
                        successCount.incrementAndGet();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    endLatch.countDown();
                }
            });
        }

            return new ByteArrayInputStream(responseBodyBytes);
        }
        if (responseBodyFile != null) {
            try {
                return new FileInputStream(responseBodyFile);
            } catch (final FileNotFoundException e) {
                throw new IORuntimeException(e);
            }
        }
        return null;
    }

    /**
     * Sets the response body from a byte array.
     *

            // Add normalized path
            if (path != null && !path.isEmpty()) {
                normalized.append(normalizePath(path));
            }

            return normalized.toString();

        } catch (MalformedURLException e) {
            throw new SmbException("Invalid SMB URL format: " + e.getMessage());
        }
    }

    /**
     * Check if path contains traversal sequences
     */

                    if (groupPrincipal != null) {
                        roleTypeList.add(systemHelper.getSearchRoleByGroup(groupPrincipal.getName()));
                    }
                }
            } catch (final IOException e) {
                throw new CrawlingAccessException("Failed to access permission info", e);
            }
            if (logger.isDebugEnabled()) {

        }
        return result;
    }

    public static String getLayout(ArtifactRepository repo) {
        try {
            return repo.getLayout().getId();
        } catch (LinkageError e) {
            /*
             * NOTE: getId() was added in 3.x and is as such not implemented by plugins compiled against 2.x APIs.
             */

        final String value = getSystemProperty(key);
        if (value != null) {
            try {
                return Integer.parseInt(value);
            } catch (final NumberFormatException e) {
                // ignore
            }
        }
        return defaultValue;
    }

    default void setSystemPropertyAsInt(final String key, final int value) {

      for (String entry : entries) {
        jarOut.putNextEntry(new ZipEntry(entry));
        Resources.copy(ClassPathTest.class.getResource(entry), jarOut);
        jarOut.closeEntry();
      }
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  private static Manifest manifest(String content) throws IOException {