.header("Connection", "upgrade")
        .header("Upgrade", "websocket")
        .header("Host", "square.com")
        .header("TE", "gzip")
        .build()
    val expected =
      headerEntries(
        ":method",
        "GET",
        ":path",
        "/",
        ":authority",
        "square.com",
        ":scheme",
        "http",
      )
    assertThat(http2HeadersList(request)).isEqualTo(expected)
  }

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.lang;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import junit.framework.TestCase;

/**
 * @author shot
 */
public class ModifierUtilTest extends TestCase {

    /**
     * @throws Exception

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 *
 */
class RequirementMatcherFactoryTest {

    /**
     * Test of createExactMatcher method, of class RequirementMatcherFactory.
     */
    @Test
    void testCreateExactMatcher() {
        RequirementMatcher matcher;
        matcher = RequirementMatcherFactory.createExactMatcher("foo");

    return emptySet();
  }

  protected Collection<Method> suppressForHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForEnumSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForSynchronizedNavigableSet() {

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  /**
   * Returns {@link Method} instances for the tests that assume that the inverse will be the same
   * after serialization.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getInverseSameAfterSerializingMethods() {
    return Collections.singletonList(getMethod("testInverseSerialization"));
  }

    expected.add(null);
    expectContents(expected);
  }

  /**
   * Returns the {@link Method} instance for {@link #testAdd_supportedNullPresent()} so that tests
   * can suppress it. See {@link CollectionAddTester#getAddNullSupportedMethod()} for details.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getAddSupportedNullPresentMethod() {

  }

  private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) {
    Set<Method> set = new HashSet<>();
    for (Method m : interfaceType.getMethods()) {
      if (declaresInterruptedEx(m)) {
        set.add(m);
      }
    }
    return set;
  }

  private static boolean declaresInterruptedEx(Method method) {
    for (Class<?> exType : method.getExceptionTypes()) {

  }

  return RequestLine(
    method = parts[0],
    target = parts[1],
    version = parts[2],
  )
}

internal class RequestLine(
  val method: String,
  val target: String,
  val version: String,
) {
  override fun toString() = "$method $target $version"
}

internal val DEFAULT_REQUEST_LINE_HTTP_1 =
  RequestLine(
    method = "GET",
    target = "/",
    version = "HTTP/1.1",

Next, we create a custom subclass of `fastapi.routing.APIRoute` that will make use of the `GzipRequest`.

This time, it will overwrite the method `APIRoute.get_route_handler()`.

This method returns a function. And that function is what will receive a request and return a response.

Here we use it to create a `GzipRequest` from the original request.

        Method method = getSuperclassMethod(response.getClass(), "getResults");
        method.setAccessible(true);
        return (FileEntry[]) method.invoke(response);
    }

    private Method getReadStringMethod() throws Exception {
        Class<?> clazz = response.getClass();
        while (clazz != null) {
            try {