ComponentUtil.setFessConfig(null);
        super.tearDown(testInfo);
    }

    private String encodeUrl(final String url) {
        try {
            return URLEncoder.encode(url, Constants.UTF_8);
        } catch (final UnsupportedEncodingException e) {
            throw new FessSystemException("Unsupported encoding.", e);
        }
    }

    @Test
    public void test_decodeUrl_ok() throws Exception {
        String url, exp;

      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

    void waitUntilHoldingLock() throws InterruptedException {
      locked.await(1, MINUTES);

      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

    void waitUntilHoldingLock() throws InterruptedException {
      locked.await(1, MINUTES);

class SIDCacheImplTest {

    // Helper to create a SID from text without throwing in the test body
    private static SID sid(String textual) {
        try {
            return new SID(textual);
        } catch (SmbException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("resolveSids(DcerpcHandle,...) populates acct, domain and type for known types")

	if err != nil {
		return nil, err
	}

	_, err = obj.Stat()
	if err != nil {
		return nil, err
	}

	return obj, nil
}

// TransferError will catch network errors during transfer.
// When TransferError() is called Close() will also
// be called, so we do not need to Wait() here.
func (w *writerAt) TransferError(err error) {
	_ = w.w.CloseWithError(err)

      assertFailsWith<IOException> {
        source.readUtf8()
      }
      try {
        assertThat(response.peekTrailers()).isNull() // Okay. This is what HTTP/1 does.
      } catch (_: IOException) {
        // Also okay. This is what HTTP/2 does.
      }
      assertFailsWith<IOException> {
        response.trailers()
      }
    }
  }

  @Test

                     * have a real NetBIOS name
                     */
                    this.calledName = null;
                    return getHostName();
                }
            } catch (final UnknownHostException uhe) {
                this.calledName = null;
            }
        } else {
            this.calledName = null;
        }

        return this.calledName;
    }

        }

        org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle lifecycleOverlay;

        try {
            lifecycleOverlay = pluginDescriptor.getLifecycleMapping(forkedLifecycle);
        } catch (IOException | XMLStreamException e) {
            throw new PluginDescriptorParsingException(pluginDescriptor.getPlugin(), pluginDescriptor.getSource(), e);
        }

        if (lifecycleOverlay == null) {

        try {
            String result = pingSearchEngineJob.execute();
            // Job should handle exception gracefully
            assertNotNull(result);
        } catch (Exception e) {
            // Exception is expected to be caught within the job
            assertTrue(e.getMessage().contains("Connection failed"));
        }
    }

      try {
        if (call.isCanceled()) {
          throw IOException("Canceled")
        }

        try {
          response = realChain.proceed(request)
          newRoutePlanner = true
        } catch (e: IOException) {
          // An attempt to communicate with a server failed. The request may have been sent.
          val isRecoverable = recover(e, call, chain, request)