}

            @Override
            public Class<?>[] groups() {
                return new Class<?>[0];
            }

            @Override
            public Class<? extends Payload>[] payload() {
                return new Class[0];
            }

            @Override
            public String minKey() {
                return "";
            }

            @Override

                .result());
    }

    /**
     * Create a new protected words entry for the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param body create request payload
     * @return JSON response containing creation result and new entry ID
     */
    // POST /api/admin/dict/protwords/setting/{dictId}
    @Execute

    private @interface ValidCronRequired {
        String message() default "Must be a valid non-blank cron expression";

        Class<?>[] groups() default {};

        Class<? extends jakarta.validation.Payload>[] payload() default {};
    }

    private static class ComposedBean {
        @ValidCronRequired
        private String composedCron;

        public String getComposedCron() {

                .result());
    }

    /**
     * Create a new character mapping entry for the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param body create request payload
     * @return JSON response containing creation result and new entry ID
     */
    // POST /api/admin/dict/mapping/setting/{dictId}
    @Execute

  }

  @Synchronized override fun onReadPing(payload: ByteString) {
    // Don't respond to pings after we've failed or sent the close frame.
    if (failed || enqueuedClose && messageAndCloseQueue.isEmpty()) return

    pongQueue.add(payload)
    runWriter()
    receivedPingCount++
  }

  @Synchronized override fun onReadPong(payload: ByteString) {
    // This API doesn't expose pings.

    const val MAX_CONCURRENT_STREAMS = 3

    /** Window size in bytes. */
    const val INITIAL_WINDOW_SIZE = 4

    /** HTTP/2: Size in bytes of the largest frame payload the sender will accept. */
    const val MAX_FRAME_SIZE = 5

    /** HTTP/2: Advisory only. Size in bytes of the largest header list the sender will accept. */
    const val MAX_HEADER_LIST_SIZE = 6

            return 200;
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return new ByteArrayInputStream(new byte[100]); // dummy payload
        }
    }

    @Test
    public void test_TmpFileHasBeenDeletedAfterResponseWasClosed() throws Exception {
        // ## Arrange ##

      requireSettings = false,
      object : BaseTestHandler() {
        override fun ping(
          ack: Boolean,
          payload1: Int,
          payload2: Int,
        ) {
          assertThat(ack).isTrue()
          assertThat(payload1).isEqualTo(expectedPayload1)
          assertThat(payload2).isEqualTo(expectedPayload2)
        }
      },
    )
  }

  @Test fun maxLengthDataFrame() {

      sink.writeByte(0b1000_0000 or lengthByteCount)
      for (shift in (lengthByteCount - 1) * 8 downTo 0 step 8) {
        sink.writeByte((length shr shift).toInt())
      }
    }

    // Write the payload.
    sink.writeAll(content)
  }

  /**
   * Execute [block] with a new namespace for type hints. Type hints from the enclosing type are no
   * longer usable by the current type's members.
   */

  }

  @Test fun closeLengthOfOneThrows() {
    data.write("880100".decodeHex()) // Close with invalid 1-byte payload
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Malformed close payload length of 1.")
    }
  }

  @Test fun closeCallsCallback() {