* @return The extracted data.
     */
    @Override
    public ExtractData getText(final InputStream in, final Map<String, String> params) {
        if (in == null) {
            throw new CrawlerSystemException("The inputstream is null.");
        }
        try {
            @SuppressWarnings("resource")
            final VisioTextExtractor visioTextExtractor = new VisioTextExtractor(in);

        assertEquals("test2.txt", info2.getFileName());
    }

    @Test
    @DisplayName("Test NotifyResponse interface with null notification list")
    void testNotifyResponseWithNullList() {
        MockNotifyResponse response = new MockNotifyResponse(null);

        List<FileNotifyInformation> notifications = response.getNotifyInformation();

        assertNotNull(notifications);

        Map<String, List<String>> headers = new HashMap<>();
        headers.put(null, Arrays.asList("value"));
        headers.put("Content-Type", Arrays.asList("application/json"));

        response.setHeaders(headers);

        Map<String, List<String>> result = response.getHeaders();
        assertNotNull(result);
        assertEquals(1, result.size()); // null key should be filtered out
        assertTrue(result.containsKey("content-type"));

    @Test
    void testLsarDomainInfoEncodeDecodeWithNulls() throws NdrException {
        // Create a domain info with null fields
        lsarpc.LsarDomainInfo domainInfo = new lsarpc.LsarDomainInfo();
        domainInfo.name = new rpc.unicode_string();
        domainInfo.name.buffer = null;
        domainInfo.sid = null;

        // Encode to buffer
        byte[] buffer = new byte[1024];

    }

    public void test_rethrow() {
        // Test rethrowing the exception
        DictionaryExpiredException originalException = null;
        DictionaryExpiredException rethrownException = null;

        try {
            try {
                throw new DictionaryExpiredException();
            } catch (DictionaryExpiredException e) {
                originalException = e;

  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

    protected int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final AllocInfo inf = createInfo();
        if (inf != null) {
            bufferIndex += inf.decode(buffer, bufferIndex, getDataCount());
            this.info = inf;
        }
        return bufferIndex - start;
    }

    /**
     * @return
     */

     * @see ArtifactCoordinates#getClassifier()
     */
    @Nonnull
    String getClassifier();

    /**
     * Returns the file extension of the artifact.
     * The dot separator is not included in the returned string.
     *
     * @return the file extension or an empty string if none, never {@code null}
     * @see ArtifactCoordinates#getExtension()

    }

    // Test convertBooleanQuery with null queryBuilder from processor
    public void test_convertBooleanQuery_withNullQueryBuilder() {
        // Create processor that returns null
        QueryProcessor nullProcessor = new QueryProcessor() {
            @Override
            public QueryBuilder execute(QueryContext context, Query query, float boost) {
                return null;
            }
        };

              new byte[] {(byte) 0xdf, (byte) 0x9b, (byte) 0x57, (byte) 0x13},
              0x13579bdf,
              null,
              "df9b5713"),
          new ExpectedHashCode(
              new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00},
              0x0000abcd,
              null,
              "cdab0000"),
          new ExpectedHashCode(
              new byte[] {