static Stream<Arguments> equalsHashParams() {
        return Stream.of(
                // byte[] id based equality (same id and tree id)
                Arguments.of(new byte[] { 0x0A, 0x0B }, new byte[] { 0x0A, 0x0B }, 100L, true),
                // fid based equality (null fileId, same fid and tree id)
                Arguments.of(null, null, 200L, true));
    }

    @ParameterizedTest(name = "equals/hashCode consistent for treeId={2}")

        if (CACHE_POLICY == 0) {
            return;
        }
        long expiration = -1;
        if (CACHE_POLICY != FOREVER) {
            expiration = System.currentTimeMillis() + CACHE_POLICY * 1000;
        }
        cacheAddress(hostName, addr, expiration);
    }

    static void cacheAddress(final Name hostName, final NbtAddress addr, final long expiration) {
        if (CACHE_POLICY == 0) {

            throw new CrawlingAccessException("Could not parse " + responseData.getUrl(), e);
        }
        final Document document = parser.getDocument();

        final StringBuilder buf = new StringBuilder(1000);
        buf.append(getResultDataHeader());
        for (final Map.Entry<String, String> entry : fieldRuleMap.entrySet()) {
            final String path = entry.getValue();
            try {

            Arrays.fill(salt, (byte) 0xFF);

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode at position 100
            int encoded = context.encode(buffer, 100);
            assertEquals(context.size(), encoded);

            // Verify salt is at correct position
            for (int i = 0; i < salt.length; i++) {

        }

        // Check total memory allocation
        long totalSize = (long) size * (long) elementSize;
        long maxAllocation = 100 * 1024 * 1024; // 100MB max

        if (totalSize > maxAllocation) {
            failedValidations.incrementAndGet();
            log.warn("Array allocation too large: {} bytes", totalSize);

        if (StringUtil.isBlank(configName)) {
            configName = StringUtils.abbreviate(configPath, 30);
        }

        // normalize
        final StringBuilder buf = new StringBuilder(1000);
        for (int i = 0; i < configPath.length(); i++) {
            final char c = configPath.charAt(i);
            if (c == '\\') {
                buf.append('/');
            } else if (c == ' ') {

    testRotate(new byte[] {1, 2, 3, 4, 5}, 6, new byte[] {5, 1, 2, 3, 4});
  }

  public void testRotateIndexed() {
    testRotate(new byte[] {}, 0, 0, 0, new byte[] {});

    testRotate(new byte[] {1}, 0, 0, 1, new byte[] {1});
    testRotate(new byte[] {1}, 1, 0, 1, new byte[] {1});
    testRotate(new byte[] {1}, 1, 1, 1, new byte[] {1});

    // Rotate the central 5 elements, leaving the ends as-is

    void testMaximumPathLength() throws Exception {
        // Given - Create a very long path
        StringBuilder longPathBuilder = new StringBuilder("\\\\server\\");
        for (int i = 0; i < 1000; i++) {
            longPathBuilder.append("a");
        }
        String longPath = longPathBuilder.toString();

        Smb2TreeConnectRequest req = new Smb2TreeConnectRequest(mockConfig, longPath);

  static final Integer N1 = 1;
  static final Integer N2 = 2;
  static final Integer N3 = 3;
  static final Integer N4 = 4;
  static final Integer N5 = 5;
  static final Integer NODE_NOT_IN_GRAPH = 1000;

  // TODO(user): Consider separating Strings that we've defined here to capture
  // identifiable substrings of expected error messages, from Strings that we've defined
  // here to provide error messages.

    /**
     * The number of URLs to fetch when polling.
     */
    protected int pollingFetchSize = 1000;

    /**
     * The maximum size of the crawling queue.
     */
    protected int maxCrawlingQueueSize = 100;

    /**
     * Creates a new instance of OpenSearchUrlQueueService.
     * @param crawlerConfig The crawler configuration.
     */