RepositorySystem repositorySystem;
            try {
                repositorySystem = container.lookup(RepositorySystem.class);
            } catch (ComponentLookupException e) {
                throw new IllegalStateException("Unable to lookup " + RepositorySystem.class.getName());
            }

            if (mirrors) {

            resultData.setData(IOUtils.toByteArray(bis));
            resultData.setEncoding(responseData.getCharSet());
            return resultData;
        } catch (final IOException e) {
            throw new CrawlerSystemException("Could not convert the input stream.", e);
        }

    }

    /**

     */
    protected String decode(final String host) {
        if (host.indexOf('%') == -1) {
            return host;
        }
        try {
            return URLDecoder.decode(host, encoding);
        } catch (final UnsupportedEncodingException e) {
            return host;
        }
    }

    /**
     * Converts the given host string to ASCII using IDN.
     *
     * @param host the host string to convert

                }
                if (values.length > 1) {
                    cb.query().setRequestedAt_LessEqual(LocalDateTime.parse(values[1], formatter));
                }
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to parse {}", pager.requestedTimeRange, e);
                }
            }
        }
    }

      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.
        Class.forName("org.openjsse.net.ssl.OpenJSSE", false, javaClass.classLoader)

        true
      } catch (_: ClassNotFoundException) {
        false
      }

    fun buildIfSupported(): OpenJSSEPlatform? = if (isSupported) OpenJSSEPlatform() else null
  }

    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testClear_unsupportedByEmptyCollection() {
    try {
      getMap().clear();
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        try {
            this.closed = true;
            close();
        } catch (final CIFSException e) {
            log.warn("Failed to close context on shutdown", e);
        }
    }

                break;
            default:
                this.checksum = new byte[bufferStream.available()];
                break;
            }
            bufferStream.readFully(this.checksum);
        } catch (final IOException e) {
            throw new PACDecodingException("Malformed PAC signature", e);
        }
    }

    /**
     * Gets the checksum type of this signature.
     *

        try {
            parser.parse(new InputSource(new StringReader(invalidXml)));
            fail("Should throw GsaConfigException");
        } catch (GsaConfigException e) {
            assertEquals("Failed to parse XML file.", e.getMessage());
        }
    }

    public void test_parseWithMalformedXml() {
        GsaConfigParser parser = new GsaConfigParser();

            listener.cacheMiss(call)
          }
        }
      }

      if (HttpMethod.invalidatesCache(networkRequest.method)) {
        try {
          cache.remove(networkRequest)
        } catch (_: IOException) {
          // The cache cannot be written.
        }
      }
    }

    return response
  }

  /**