leaseContext = new LeaseV1CreateContextRequest(testKey, testState);
    }

    @Test
    @DisplayName("Should have correct context name")
    void testContextName() {
        assertArrayEquals("RqLs".getBytes(), leaseContext.getName());
        assertEquals("RqLs", LeaseV1CreateContextRequest.CONTEXT_NAME);
    }

    @Test
    @DisplayName("Should initialize with default values")
    void testDefaultConstructor() {

        byte[] src = expected.getBytes("UTF-16LE");
        String result = response.readString(src, 0, src.length);
        assertEquals(expected, result);
    }

    @Test
    void testReadString_Oem() {
        response.useUnicode = false;
        String expected = "test";
        // Simulate OEM encoding with a null terminator
        byte[] src = (expected + "\0").getBytes(StandardCharsets.UTF_8);

            byte[] data = "Hello World Test".getBytes();
            InputStream is = new ByteArrayInputStream(data);
            byte[] buffer = new byte[20];

            int bytesRead = Transport.readn(is, buffer, 0, 5);
            assertEquals(5, bytesRead);
            assertArrayEquals("Hello".getBytes(), java.util.Arrays.copyOfRange(buffer, 0, 5));
        }

        @Test

import javax.security.auth.kerberos.KerberosPrincipal;

import org.junit.jupiter.api.Test;

/**
 * Tests for the PacMac class.
 */
class PacMacTest {

    private static final byte[] TEST_DATA = "test data".getBytes();
    private static final KerberosPrincipal TEST_PRINCIPAL = new KerberosPrincipal("test@REALM");

    /**
     * Test method for
     * {@link jcifs.pac.PacMac#calculateMacArcfourHMACMD5(int, java.security.Key, byte[])}.

                testEncryptionKey, testEncryptionKey); // Use same key for test

        byte[] plaintext = "Hello, SMB3 Encryption!".getBytes();
        long sessionId = 0x123456789ABCDEF0L;

        // When - Encrypt
        byte[] encrypted = context.encryptMessage(plaintext, sessionId);

        // Then - Verify encrypted message structure

    }

    @Test
    void calculateByte() throws IOException {
        Map<ChecksumAlgorithmService.ChecksumAlgorithm, String> checksums = service.calculate(
                "test".getBytes(StandardCharsets.UTF_8), service.select(Arrays.asList("SHA-1", "MD5")));
        assertNotNull(checksums);
        assertEquals(2, checksums.size());

        try {
            resultData.setData(content.getBytes(charsetName));
        } catch (final UnsupportedEncodingException e) {
            if (logger.isInfoEnabled()) {
                logger.info("Invalid charsetName: " + charsetName + ". Changed to " + Constants.UTF_8, e);
            }
            charsetName = Constants.UTF_8;
            resultData.setData(content.getBytes(Constants.UTF_8_CHARSET));
        }

        // Verify subcommand
        assertEquals(SmbComTransaction.NET_SERVER_ENUM2 & 0xFF, (dst[0] & 0xFF) | ((dst[1] & 0xFF) << 8));

        // Verify description
        byte[] descr = NetServerEnum2.DESCR[0].getBytes("ASCII");
        byte[] writtenDescr = new byte[descr.length];
        System.arraycopy(dst, 2, writtenDescr, 0, descr.length);
        assertArrayEquals(descr, writtenDescr);

        int currentIndex = 2 + descr.length;

    }

    public void test_name() {
        assertEquals("htmlTransformer", htmlTransformer.getName());
    }

    public void test_transform() {
        final byte[] data = new String("xyz").getBytes();
        final ResponseData responseData = new ResponseData();
        responseData.setUrl("http://hoge/");
        responseData.setResponseBody(data);
        responseData.setCharSet("ISO-8859-1");

        // Write initial content
        try (OutputStream out = file.openOutputStream(false)) {
            out.write(initialContent.getBytes("UTF-8"));
        }

        // Overwrite with new content
        try (OutputStream out = file.openOutputStream(false)) {
            out.write(newContent.getBytes("UTF-8"));
        }

        // Verify new content
        try (InputStream in = file.getInputStream()) {