}
		retries++
		time.Sleep(time.Duration(rand.Int63n(int64(time.Second))))
	}

	if retries == 5 {
		scannerLogOnceIf(ctx, fmt.Errorf("maximum retry reached to load the data usage cache `%s`", name), "retry-loading-data-usage-cache")
	}

	return nil
}

// Maximum running concurrent saves on server.
var maxConcurrentScannerSaves = make(chan struct{}, 4)

        assertTrue(addr.isActive);
        assertTrue(addr.isPermanent);
    }

    @Test
    void readRDataWireFormat_shouldHandleMultipleNames() throws Exception {
        // Test with maximum reasonable number of names
        int numNames = 10;
        int dataLength = 1 + (18 * numNames) + 6 + 6;
        byte[] src = new byte[dataLength];
        int srcIndex = 0;

            request.writeBytesWireFormat(smallBuffer, 0);
        });
    }

    @Test
    @DisplayName("Test file ID boundary values")
    void testFileIdBoundaryValues() {
        // Test with file ID having maximum byte values
        byte[] maxFileId = new byte[16];
        Arrays.fill(maxFileId, (byte) 0xFF);
        Smb2CloseRequest maxRequest = new Smb2CloseRequest(mockConfig, maxFileId, testFileName);

        }
    }

    @Nested
    @DisplayName("Edge Cases and Boundary Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum path length")
        void testMaximumPathLength() {
            // Create a very long path (but not too long to cause memory issues)
            StringBuilder sb = new StringBuilder("\\\\server");

  }

  private static final Object NOT_FOUND = new Object();

  /**
   * Maximum allowed false positive probability of detecting a hash flooding attack given random
   * input.
   */
  @VisibleForTesting(
      )
  static final double HASH_FLOODING_FPP = 0.001;

  /**
   * Maximum allowed length of a hash table bucket before falling back to a j.u.LinkedHashMap-based

                if (maxDate && end.isAfter(maxDate))
                    end = maxDate.clone();

                // If the end of the range is before the minimum or the start of the range is
                // after the maximum, don't display this range option at all.
                if ((this.minDate && end.isBefore(this.minDate, this.timepicker ? 'minute' : 'day'))
                  || (maxDate && start.isAfter(maxDate, this.timepicker ? 'minute' : 'day')))

    /**
     * Cache for storing resource file modification timestamps to enable cache busting.
     * The cache expires after 10 minutes and has a maximum size of 1000 entries.
     */
    private static LoadingCache<String, Long> resourceHashCache =
            CacheBuilder.newBuilder().maximumSize(1000).expireAfterWrite(10, TimeUnit.MINUTES).build(new CacheLoader<String, Long>() {

     *
     * @return initial security blob
     */
    public byte[] getSecurityBlob() {
        return this.securityBuffer;
    }

    /**
     * Gets the maximum transaction size supported by the server.
     *
     * @return the maxTransactSize
     */
    public int getMaxTransactSize() {
        return this.maxTransactSize;
    }

    /**

            assertArrayEquals(Arrays.copyOfRange(fullData, offset, offset + length), Arrays.copyOfRange(buffer, 48, 48 + length));
        }

        @Test
        @DisplayName("Should handle maximum values correctly")
        void testMaximumValues() {
            request.setOffset(Long.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);
            request.setWriteFlags(Integer.MAX_VALUE);

        assertNotNull(crawlerContext.removeSitemaps());
    }

    /**
     * Test boundary values
     */
    public void test_boundaryValues() {
        // Test with maximum values
        crawlerContext.setActiveThreadCount(Integer.MAX_VALUE);
        assertEquals(Integer.MAX_VALUE, crawlerContext.getActiveThreadCount().intValue());

        crawlerContext.setNumOfThread(Integer.MAX_VALUE);