assertEquals("text/plain", responseData.getMimeType());
        assertTrue(responseData.getUrl().endsWith("test/text1.txt"));
        final String content = new String(InputStreamUtil.getBytes(responseData.getResponseBody()), "UTF-8");
        assertEquals("test1", content.trim());
    }

    public void test_doGet_file_with_space() throws Exception {

     * <p>
     * The input stream is not closed.
     * </p>
     *
     * @param is the input stream (must not be {@literal null})
     * @return the byte array
     */
    public static final byte[] getBytes(final InputStream is) {
        assertArgumentNotNull("is", is);

        final ByteArrayOutputStream os = new ByteArrayOutputStream(BUF_SIZE);
        CopyUtil.copy(is, os);
        return os.toByteArray();
    }

    /**
     * Context name for durable handle V2 response
     */
    public static final String CONTEXT_NAME = "DH2Q";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();

    private long timeout100Ns; // timeout in 100-nanosecond intervals (wire format, unsigned 32-bit)
    private int flags;

    /**
     * Create a new durable handle V2 response
     */

        assertTrue(content.contains("テスト"));
        assertEquals("タイトル", data.getValues("title")[0]);
    }

    public void test_getHtml_empty() {
        final InputStream in = new ByteArrayInputStream("".getBytes());
        final String content = htmlExtractor.getText(in, null).getContent();
        CloseableUtil.closeQuietly(in);
        logger.info(content);
        assertEquals("", content);
    }

     * Test getData implementation
     */
    public void test_getData_implementation() {
        AccessResultData<String> accessResultData = new AccessResultData<String>() {
            private byte[] data = "test data".getBytes();
            private String encoding = "UTF-8";
            private String transformerName = "test";
            private String id;

            @Override
            public String getId() {

        SMBUtil.writeInt8(0x0123456789ABCDEFL, timestampData, 0);
        byte[] avTimestampData = createAvPairData(AvPair.MsvAvTimestamp, timestampData);

        byte[] targetNameData = "TEST".getBytes();
        byte[] avTargetNameData = createAvPairData(AvPair.MsvAvTargetName, targetNameData);

        byte[] eolData = createEolData();

        // Combine all data

        keys = new HashMap<>();
        // Use ARCFOUR-HMAC encryption type (23) which matches KERB_CHECKSUM_HMAC_MD5
        KerberosKey serverKey = new KerberosKey(new KerberosPrincipal("******@****.***"), "serverKey1234567".getBytes(),
                PacSignature.ETYPE_ARCFOUR_HMAC, 1);
        keys.put(PacSignature.ETYPE_ARCFOUR_HMAC, serverKey);
    }

    private void writeLittleEndianInt(ByteArrayOutputStream baos, int value) {

    /**
     * Context name for durable handle reconnect
     */
    public static final String CONTEXT_NAME = "DHnC";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();
    private static final int STRUCTURE_SIZE = 16;

    private byte[] fileId; // 16-byte file ID from previous open

    /**
     * Create a new durable handle reconnect context

    private SmbComNegotiateResponse mockNegotiate;
    @Mock
    private ServerMessageBlock mockAndX;
    @Mock
    private Configuration mockConfig;

    private static byte[] blobCred() {
        return "blobdata".getBytes(StandardCharsets.UTF_8);
    }

    @BeforeEach
    void setup() {
        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockNegotiate.getServerData()).thenReturn(new ServerDataStub());
    }

    }

    /**
     * Test constructor with a malformed token (not ASN.1).
     */
    @Test
    void testConstructorWithMalformedToken() {
        byte[] malformedToken = "This is not a valid token".getBytes();
        assertThrows(PACDecodingException.class, () -> new KerberosToken(malformedToken));
    }

    /**
     * Test constructor with a token that has an incorrect OID.
     *