final InputStream in = new ByteArrayInputStream(testContent.getBytes());

        final ExtractData result = textExtractor.getText(in, null);

        assertNotNull(result);
        assertNotNull(result.getContent());
        assertTrue(result.getContent().contains("Test content"));
    }

    /**
     * Test successful text extraction with custom encoding.
     */

        assertNotNull(response);
    }

    @Test
    public void test_setSuggestDetail() throws Exception {
        indexItems();

        SuggestResponse response = suggester.suggest().setQuery("test").setSuggestDetail(true).execute().getResponse();

        assertNotNull(response);
        if (response.getNum() > 0) {
            assertNotNull(response.getItems());
        }
    }

            SpnegoException ex1 = new SpnegoException((String) null);
            assertNotNull(ex1);
            assertNull(ex1.getMessage());
            assertNull(ex1.getCause());
        });

        assertDoesNotThrow(() -> {
            SpnegoException ex2 = new SpnegoException("msg", null);
            assertNotNull(ex2);
            assertEquals("msg", ex2.getMessage());
            assertNull(ex2.getCause());

        AvFlags avFlags = new AvFlags(rawBytes);
        assertNotNull(avFlags, "AvFlags object should not be null");
        assertEquals(0x04030201, avFlags.getFlags(), "Flags should match the raw bytes (little-endian)");

        // Test with zero
        byte[] zeroBytes = new byte[] { 0x00, 0x00, 0x00, 0x00 };
        AvFlags zeroAvFlags = new AvFlags(zeroBytes);
        assertNotNull(zeroAvFlags, "AvFlags object should not be null for zero bytes");

        byte[] mac = PacMac.calculateMacArcfourHMACMD5(3, key, TEST_DATA);
        assertNotNull(mac);
        assertEquals(16, mac.length);

        // Test with a different key usage
        byte[] mac2 = PacMac.calculateMacArcfourHMACMD5(9, key, TEST_DATA);
        assertNotNull(mac2);
        assertEquals(16, mac2.length);

        // Test with another key usage

        AvSingleHost avSingleHost = new AvSingleHost(mockConfig);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());
        byte[] value = avSingleHost.getRaw();
        assertNotNull(value);
        assertEquals(48, value.length); // Expected size: 8 + 8 + 32

        // Verify the machine ID part

        assertNotNull(normalizer);
    }

    @Test
    public void test_normalizeWithDefaultLanguage() throws Exception {
        AnalyzerNormalizer normalizer = new AnalyzerNormalizer(runner.client(), suggester.settings());

        String result = normalizer.normalize("test", "content");

        assertNotNull(result);
    }

    @Test

        assertNotNull(response);
        assertEquals(24, response.length);
    }

    // Test getNTLMResponse
    @Test
    void testGetNTLMResponse() {
        byte[] challenge = { 1, 2, 3, 4, 5, 6, 7, 8 };
        byte[] response = NtlmPasswordAuthentication.getNTLMResponse("password", challenge);
        assertNotNull(response);
        assertEquals(24, response.length);

        final Map<String, String> params = new HashMap<>();
        params.put(ExtractData.RESOURCE_NAME_KEY, "test-document.pdf");

        final ExtractData result = filenameExtractor.getText(in, params);

        assertNotNull(result);
        assertEquals("test-document.pdf", result.getContent());
    }

    /**
     * Test extraction with null parameters map.
     */
    public void test_getText_withNullParams() {

            try {
                Pac pac = new Pac(pacData, keys);
                assertNotNull(pac.getServerSignature());
                assertNotNull(pac.getKdcSignature());
            } catch (PACDecodingException e) {
                // Expected due to invalid logon info structure
                assertNotNull(e.getMessage());
            }
        }
    }