assertEquals(0, result);
    }

    @Test
    void testReadDataWireFormatAtBufferBoundary() throws SMBProtocolDecodingException {
        // Test with data length exactly matching outputBuffer size
        byte[] testData = new byte[outputBuffer.length];
        Arrays.fill(testData, (byte) 0xFF);
        byte[] buffer = new byte[outputBuffer.length + 100];

 * HTTP/2 support allows all requests to the same host to share a socket.
 * Connection pooling reduces request latency (if HTTP/2 isn’t available).
 * Transparent GZIP shrinks download sizes.
 * Response caching avoids the network completely for repeat requests.

OkHttp perseveres when the network is troublesome: it will silently recover from common connection

     * Retrieves a paginated list of failure URLs based on the provided pager criteria.
     *
     * @param failureUrlPager the pager containing search criteria and pagination settings
     * @return a list of FailureUrl entities matching the criteria
     */
    public List<FailureUrl> getFailureUrlList(final FailureUrlPager failureUrlPager) {

        final PagingResultBean<FailureUrl> failureUrlList = failureUrlBhv.selectPage(cb -> {

  // Create a second ClassLoader and use it to get a second version of the TestEnum class.
  // Run Enums.getIfPresent on that other TestEnum and then return a WeakReference containing the
  // new ClassLoader. If Enums.getIfPresent does caching that prevents the shadow TestEnum
  // (and therefore its ClassLoader) from being unloaded, then this WeakReference will never be
  // cleared.
  @J2ktIncompatible

        // Clear conditions
        rule.clearConditions();

        // Should match after clearing conditions
        assertTrue(rule.match(responseData));
    }

    /**
     * Test rule matching with various ResponseData states
     */
    public void test_matchWithVariousResponseDataStates() {
        ConfigurableRule rule = new ConfigurableRule();
        rule.setRuleId("stateRule");

import org.opensearch.search.sort.SortBuilders;
import org.opensearch.search.sort.SortOrder;

/**
 * Fess-specific URL queue service that extends OpenSearch URL queue functionality.
 * This service provides customized URL fetching strategies including sequential and random ordering
 * based on crawling configuration parameters.
 */
public class FessUrlQueueService extends OpenSearchUrlQueueService {

 *         .maxStale(365, TimeUnit.DAYS)
 *         .build())
 *     .url("http://publicobject.com/helloworld.txt")
 *     .build();
 * ```
 *
 * The [CacheControl] class can configure request caching directives and parse response caching
 * directives. It even offers convenient constants [CacheControl.FORCE_NETWORK] and
 * [CacheControl.FORCE_CACHE] that address the use cases above.
 *
 * [rfc_7234]: http://tools.ietf.org/html/rfc7234

            if (pin.hash == sha1) return // Success!
          }
          else -> throw AssertionError("unsupported hashAlgorithm: ${pin.hashAlgorithm}")
        }
      }
    }

    // If we couldn't find a matching pin, format a nice exception.
    val message =
      buildString {
        append("Certificate pinning failure!")
        append("\n  Peer certificate chain:")
        for (element in peerCertificates) {

     * by sort order, creation time, regular name, and duplicate hostname.</p>
     *
     * @param duplicateHostPager the pager containing search criteria and pagination settings
     * @return a list of DuplicateHost entities matching the search criteria
     * @throws IllegalArgumentException if duplicateHostPager is null
     */
    public List<DuplicateHost> getDuplicateHostList(final DuplicateHostPager duplicateHostPager) {

        factory.addClient(regexList, client);
    }

    /**
     * Retrieves a client from the wrapped factory that matches the given URL.
     * @param url The URL to match.
     * @return The matching CrawlerClient instance.
     */
    @Override
    public CrawlerClient getClient(final String url) {
        return factory.getClient(url);
    }

    /**