import org.codelibs.fess.crawler.client.http.config.WebAuthenticationConfig;
import org.codelibs.fess.crawler.client.http.config.WebAuthenticationConfig.AuthSchemeType;
import org.codelibs.fess.crawler.exception.CrawlerSystemException;
import org.codelibs.fess.opensearch.config.bsentity.BsWebAuthentication;
import org.codelibs.fess.opensearch.config.exentity.CrawlingConfig.ConfigName;

   */
  public static void assertBasic(Escaper escaper) throws IOException {
    // Escapers operate on characters: no characters, no escaping.
    Assert.assertEquals("", escaper.escape(""));
    // Assert that escapers throw null pointer exceptions.
    try {
      escaper.escape((String) null);
      Assert.fail("exception not thrown when escaping a null string");
    } catch (NullPointerException e) {
      // pass

   */
  public static void assertBasic(Escaper escaper) throws IOException {
    // Escapers operate on characters: no characters, no escaping.
    Assert.assertEquals("", escaper.escape(""));
    // Assert that escapers throw null pointer exceptions.
    try {
      escaper.escape((String) null);
      Assert.fail("exception not thrown when escaping a null string");
    } catch (NullPointerException e) {
      // pass

     * will throw an exception if there are duplicate keys. The {@code build()} method will soon be
     * deprecated.
     *
     * @throws IllegalArgumentException if duplicate keys were added
     */
    public ImmutableMap<K, V> build() {
      return buildOrThrow();
    }

    /**
     * Returns a newly-created immutable map, or throws an exception if any key was added more than

            } else {
                enc = encoding;
            }

            try {
                url = URLDecoder.decode(url, enc);
            } catch (final Exception e) {
                // Failed to decode URL, using original URL as-is
                if (getLogger().isDebugEnabled()) {
                    getLogger().debug("Failed to decode URL with encoding {}: {}", enc, url, e);

                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (final IOException ioe) {
                        // Ignore close exception
                    }
                }
                if (newFile != null) {

        assertNotNull(request2);
        assertTrue("Factory methods should return different instances", request1 != request2);
    }

    @Test
    public void test_ProtectedConstructor() throws Exception {
        // ## Test that protected constructor can be accessed via reflection ##

        // ## Act ##
        final Constructor<Curl> constructor = Curl.class.getDeclaredConstructor();

        // Test engineDigest(byte[] buf, int offset, int len) throws exception
        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {
            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            byte[] innerDigest = "inner_digest".getBytes();

            when(mockMd5.digest()).thenReturn(innerDigest);
            doThrow(new RuntimeException("Test Exception")).when(mockMd5).digest(any(byte[].class), anyInt(), anyInt());

    @Inject
    protected RepositorySystem system;

    @Inject
    protected PlexusContainer container;

    protected RepositorySystemSession session;

    @BeforeEach
    public void setUp() throws Exception {
        session = newMavenRepositorySystemSession(system);
    }

    protected PlexusContainer getContainer() {
        return container;
    }

        BuildLogger antLogger = makeLogger(stream, outputLevel)

        ant.project.addBuildListener(antLogger)
        try {
            runAnt(ant)
        } catch (Exception e) {
            // ant failed, so see if we have buffered output to emit, then rethrow the failure
            String buffer = outputBuffer.toString()
            if (buffer.isEmpty() == false) {