SmbException thrown = assertThrows(SmbException.class, () -> {
            dosFileFilter.accept(mockFile);
        });

        // and the exception should be the one we configured
        assertTrue(thrown == expectedException);
    }

        @Test
        @DisplayName("Should handle basic send/receive fragment methods")
        void testSendReceiveFragmentMethods() throws IOException {
            // Given: Test handle with configured return values
            handle.setDoSendReceiveFragmentReturn(100);
            handle.setDoReceiveFragmentReturn(50);

            // When: Calling fragment methods

# Templates { #templates }

Você pode usar qualquer template engine com o **FastAPI**.

Uma escolha comum é o Jinja2, o mesmo usado pelo Flask e outras ferramentas.

Existem utilitários para configurá-lo facilmente que você pode usar diretamente em sua aplicação **FastAPI** (fornecidos pelo Starlette).

## Instalar dependências { #install-dependencies }

 *
 * <h2>Repository Configuration</h2>
 *
 * <p>Repositories can be configured at various levels:</p><ol>
 * <li>POM: Repositories can be specified in the {@code pom.xml} file under the {@code <repositories>} and {@code <pluginRepositories>} sections.</li>

            extensionDoc.getExtraProperties().add(propertyDoc);

            para = doc.createElement("para");
            para.appendChild(doc.createTextNode("Configures the "));
            para.appendChild(linkRenderer.link(propertyMetaData.getType(), listener));
            para.appendChild(doc.createTextNode(String.format(" added by the %s plugin.", extensionDoc.getPluginId())));

        }

        @Test
        @DisplayName("Should throw configured exception on decode")
        void testConfiguredExceptionOnDecode() {
            testResponse.setThrowOnDecode(true);

            assertThrows(SMBProtocolDecodingException.class, () -> testResponse.decode(testBuffer, 0, 10),
                    "Should throw configured exception");
        }

        @ParameterizedTest

     */
    public DataIndexHelper() {
        // Default constructor with explicit documentation
    }

    /**
     * Initiates crawling for all configured data stores.
     * This method retrieves all available data configurations and
     * starts the crawling process for each one.
     *
     * @param sessionId unique identifier for this crawling session
     */

 * and optionally at specific positions in the processing order.</p>
 *
 * <p>This factory is typically initialized through dependency injection and can be
 * configured with initialization parameters that are passed to all registered clients.</p>
 *
 * <p>Features:</p>
 * <ul>
 *   <li>Pattern-based client mapping</li>
 *   <li>Ordered client registration</li>

/**
 * RegexRule is a rule implementation that uses regular expressions to match against the ResponseData.
 * It allows defining multiple regular expressions for different fields of the ResponseData.
 * The rule can be configured to require all regular expressions to match (allRequired = true) or
 * only one of them (allRequired = false). It also supports a default rule that always matches.
 *
 * <p>

		return true
	}

	parsedTags, err := tags.ParseObjectTags(userTags)
	if err != nil {
		return false
	}

	tagsMap := parsedTags.ToMap()

	// This filter has tags configured but this object
	// does not have any tag, skip this object
	if len(tagsMap) == 0 {
		return false
	}

	// Both filter and object have tags, find a match,
	// skip this object otherwise