val webSocket: WebSocket?,
  val body: String?,
  val failure: IOException?,
) {
  fun assertRequestUrl(url: HttpUrl) =
    apply {
      assertThat(request.url).isEqualTo(url)
    }

  fun assertRequestMethod(method: String) =
    apply {
      assertThat(request.method).isEqualTo(method)
    }

  fun assertRequestHeader(
    name: String,
    vararg values: String,
  ) = apply {

interface LoggerAdapter {

    boolean isFatalEnabled();

    void fatal(String message);

    void fatal(String message, Throwable t);

    boolean isErrorEnabled();

    void error(String message);

    void error(String message, Throwable t);

    boolean isWarnEnabled();

    void warn(String message);

    void warn(String message, Throwable t);

    boolean isInfoEnabled();

        map = new HashMap<String, String>();
        assertThat(CollectionsUtil.isEmpty(map), is(true));
    }

    /**
     * Test method for
     * {@link org.codelibs.core.collection.CollectionsUtil#isNotEmpty(java.util.Map)}
     * .
     */
    @Test
    public void testIsNotEmptyMapOfQQ() {
        final HashMap<String, String> map = new HashMap<String, String>();
        map.put("key", "value");

    /**
     * Test implementation of RequestWithPath interface for testing purposes
     */
    private static class TestRequestWithPath implements RequestWithPath {
        private String path;
        private String server;
        private String domain;
        private String fullUNCPath;
        private boolean resolveInDfs;

        @Override
        public String getPath() {
            return path;
        }

    int i = 0;
    for (Object o : entries) {
      @SuppressWarnings("unchecked")
      Entry<String, String> e = (Entry<String, String>) o;
      array[i++] = e;
    }
    return create(array);
  }

  protected abstract ListMultimap<String, String> create(Entry<String, String>[] entries);

  @Override
  @SuppressWarnings("unchecked")

    int i = 0;
    for (Object o : entries) {
      @SuppressWarnings("unchecked")
      Entry<String, String> e = (Entry<String, String>) o;
      array[i++] = e;
    }
    return create(array);
  }

  protected abstract SetMultimap<String, String> create(Entry<String, String>[] entries);

  @Override
  @SuppressWarnings("unchecked")

    }
  }

  private static class Request {
    final String methodName;
    final Object[] arguments;

    Request(String methodName, Object[] arguments) {
      this.methodName = checkNotNull(methodName);
      this.arguments = checkNotNull(arguments);
    }
  }

  private static class Response {
    final String methodName;
    final Object result;
    final Throwable throwable;

    public void testEncode_EmptyArray() throws Exception {
        final String result = Base64Util.encode(new byte[0]);
        assertEquals("Empty array should return empty string", "", result);
    }

    /**
     * Test encode with null returns empty string
     *
     * @throws Exception
     */
    public void testEncode_Null() throws Exception {
        final String result = Base64Util.encode(null);

         */
        protected Pair<String, String> splitField(final String defaultField, final String field) {
            final int indexOf = field.indexOf(':');
            if (indexOf < 0) {
                return new Pair<>(field, null);
            }
            final String indexField = indexOf == 0 ? defaultField : field.substring(0, indexOf);
            final String extensionKey = field.substring(indexOf + 1);

     * @return resolved addresses
     * @throws java.net.UnknownHostException
     *             if there is an error resolving the name
     */
    NetbiosAddress[] getNbtAllByAddress(String host, int type, String scope) throws UnknownHostException;

    /**
     * Retrieve all addresses of a host by it's address. NetBIOS hosts can
     * have many names for a given IP address. The name and IP address make the