}

  @Test fun `skip whitespace after boundary`() {
    val multipart =
      """
      |--simple boundary
      |
      |abcd
      |--simple boundary--
      """.trimMargin()
        .replace(Regex("(?m)simple boundary$"), "simple boundary \t \t")
        .replace("\n", "\r\n")

    val parts =
      MultipartReader(
        boundary = "simple boundary",
        source = Buffer().writeUtf8(multipart),

      source = response.source(),
      boundary =
        response.contentType()?.parameter("boundary")
          ?: throw ProtocolException("expected the Content-Type to have a boundary parameter"),
    )

    @Throws(IOException::class)
    fun nextPart(): Part? {
      check(!closed) { "closed" }

      if (noMoreParts) return null

      // Read a boundary, skipping the remainder of the preceding part as necessary.

     */
    boolean contains(@Nonnull Version version);

    /**
     * Returns the upper boundary of this range, or {@code null} if none.
     */
    @Nullable
    Boundary getUpperBoundary();

    /**
     * Returns the lower boundary of this range, or {@code null} if none.
     */
    @Nullable
    Boundary getLowerBoundary();

    /**
     * {@return the string representation of this version}
     */

    }

    /**
     * Aligns the buffer index to the specified boundary with a fill value.
     *
     * @param boundary the alignment boundary
     * @param value the fill value for padding
     * @return the number of bytes added for alignment
     */
    public int align(final int boundary, final byte value) {
        final int n = align(boundary);
        int i = n;
        while (i > 0) {

    }

    /**
     * Aligns the buffer index to the specified boundary with a fill value.
     *
     * @param boundary the alignment boundary
     * @param value the fill value for padding
     * @return the number of bytes added for alignment
     */
    public int align(final int boundary, final byte value) {
        final int n = align(boundary);
        int i = n;
        while (i > 0) {

        this.epoch = epoch;
    }

    @Override
    public int size() {
        // Context header: 16 bytes
        // Name: 4 bytes ("RqL2")
        // Padding: 4 bytes (to align data to 8-byte boundary)
        // Data: 52 bytes (lease V2 structure)
        return 16 + 4 + 4 + 52;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        int start = dstIndex;

            assertEquals(0, request.getData().length);
        }

        @Test
        @DisplayName("Should handle boundary conditions in encode")
        void testBoundaryConditions() {
            byte[] buffer = new byte[256];
            byte[] name = "BOUNDARY".getBytes(StandardCharsets.UTF_8);
            TestCreateContextRequest request = new TestCreateContextRequest(name);

  static final Iterable<Integer> NONZERO_INTEGER_CANDIDATES;

  static final Iterable<Integer> ALL_INTEGER_CANDIDATES;

  static {
    ImmutableSet.Builder<Integer> intValues = ImmutableSet.builder();
    // Add boundary values manually to avoid over/under flow (this covers 2^N for 0 and 31).
    intValues.add(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
    // Add values up to 40. This covers cases like "square of a prime" and such.

            verify(buffer2).dec_ndr_short();
            assertEquals(75, ndrShort.value);
        }

        @Test
        @DisplayName("Should handle boundary values correctly")
        void testBoundaryValues() {
            // Test various boundary values
            assertEquals(0, new NdrShort(0).value);
            assertEquals(255, new NdrShort(255).value);

                assertNotNull(message, String.format("Message for code %d should not be null", code));
            }
        }
    }

    @Nested
    @DisplayName("Boundary conditions")
    class Boundary {
        @Test
        void accessingInvalidIndexThrows() {
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {