TYPE_RST_STREAM -> readRstStream(handler, length, flags, streamId)
      TYPE_SETTINGS -> readSettings(handler, length, flags, streamId)
      TYPE_PUSH_PROMISE -> readPushPromise(handler, length, flags, streamId)
      TYPE_PING -> readPing(handler, length, flags, streamId)
      TYPE_GOAWAY -> readGoAway(handler, length, flags, streamId)
      TYPE_WINDOW_UPDATE -> readWindowUpdate(handler, length, flags, streamId)

    }

    // Test default values
    @Test
    public void test_defaultValues() throws Exception {
        assertEquals("Default message should match", "{org.lastaflute.validator.constraints.UriType.message}", getDefaultMessage());
        assertEquals("Default groups should be empty", 0, getDefaultGroups().length);

            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 440)).length());
            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 450)).length());
            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 460)).length());
            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 470)).length());

      implements TestMapGenerator<Class<?>, Impl> {

    @Override
    public Class<?>[] createKeyArray(int length) {
      return new Class<?>[length];
    }

    @Override
    public Impl[] createValueArray(int length) {
      return new Impl[length];
    }

    @Override
    public SampleElements<Entry<Class<?>, Impl>> samples() {
      return new SampleElements<>(

    }

    @Test
    public void test_getFieldValues_emptyList() throws Exception {
        Map<String, Object> document = new HashMap<>();
        document.put("field", new ArrayList<>());

        String[] values = parser.getFieldValues(document, "field");

        assertEquals("Empty list should return empty array", 0, values.length);
    }

    @Test

    }

    if (slice && bytes.length > 0) {
      // test a random slice() of the ByteSource
      Random random = new Random();
      byte[] expected = factory.getExpected(bytes);
      // if expected.length == 0, off has to be 0 but length doesn't matter--result will be empty
      int off = expected.length == 0 ? 0 : random.nextInt(expected.length);
      int len = expected.length == 0 ? 4 : random.nextInt(expected.length - off);

        String[] values = new String[1000];
        for (int i = 0; i < values.length; i++) {
            values[i] = "value" + i;
        }
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());
        assertNotNull(param.getValues());
        assertEquals(1000, param.getValues().length);
        assertEquals("value0", param.getValues()[0]);

    }
    ListenableFuture<Integer> stackDepthCheck =
        serializer.submit(() -> Thread.currentThread().getStackTrace().length, directExecutor());
    settableFuture.set(null);
    assertThat(getDone(stackDepthCheck))
        .isLessThan(Thread.currentThread().getStackTrace().length + 100);
  }

  public void testAvoidsStackOverflow_alternatingCancelledAndSubmitted() throws Exception {

    public Entry<Country, String>[] createArray(int length) {
      return (Entry<Country, String>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<Country, String>> order(List<Entry<Country, String>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public Country[] createKeyArray(int length) {
      return new Country[length];
    }

    @Override

        headers.put("Content-Length", Arrays.asList("100"));

        response.setHeaders(headers);

        Map<String, List<String>> result = response.getHeaders();
        assertNotNull(result);
        // Headers should be stored in lowercase
        assertTrue(result.containsKey("content-type"));
        assertTrue(result.containsKey("content-length"));
    }

    @Test