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, () -> {

        this.leaseFlags = leaseFlags;
    }

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

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

            }
        }
    }

    @Nested
    @DisplayName("Edge Cases and Boundary Tests")
    class EdgeCasesTests {

        @ParameterizedTest
        @DisplayName("Should handle boundary values for capacity")
        @ValueSource(longs = { 0L, 1L, -1L, 1024L, 1048576L, 1073741824L, Long.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE - 1,

        // Then
        assertEquals(expectedMid, actualMid);
        verify(messageBlock).setMid(expectedMid);
        verify(messageBlock).getMid();
    }

    @Test
    @DisplayName("Test setMid with boundary values")
    void testSetMidWithBoundaryValues() {
        // Test with MAX_VALUE
        long maxMid = Long.MAX_VALUE;
        doNothing().when(messageBlock).setMid(maxMid);

  }

  @Test @Disabled
  fun multipartBody() {
    val multipartBody: MultipartBody = MultipartBody.Builder().build()
    val type: MediaType = multipartBody.type()
    val boundary: String = multipartBody.boundary()
    val size: Int = multipartBody.size()
    val parts: List<MultipartBody.Part> = multipartBody.parts()
  }

  @Test @Disabled
  fun multipartBodyPart() {

        @Test
        @DisplayName("Should return correct size")
        void testSize() {
            int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 4;
            // size8 rounds up to 8-byte boundary
            int expectedAlignedSize = (expectedSize + 7) & ~7;

            assertEquals(expectedAlignedSize, echoRequest.size());
        }

        @Test