}

    @Test
    public void testEncryptDecryptLongPassword() throws Exception {
        // Test with very long password
        char[] plaintext = new char[10000];
        Arrays.fill(plaintext, 'X');

        byte[] encrypted = storage.encryptCredentials(plaintext);
        assertNotNull(encrypted, "Encrypted long password should not be null");

    List<StringCatcher> catchers = new CopyOnWriteArrayList<>();
    List<Future<?>> futures = new ArrayList<>();
    ExecutorService executor = newFixedThreadPool(10);
    int numberOfCatchers = 10000;
    for (int i = 0; i < numberOfCatchers; i++) {
      futures.add(executor.submit(new Registrator(bus, catchers)));
    }
    for (int i = 0; i < numberOfCatchers; i++) {
      futures.get(i).get();
    }

                    String fileName = "thread" + threadId + "_file" + j + ".txt";
                    entry.updateChild(fileName, j * 100L, System.currentTimeMillis(), false, 0x20, System.currentTimeMillis() - 10000,
                            System.currentTimeMillis() - 5000);
                }
            });
            updateThreads[i].start();
        }

        // Test concurrent reads

        String circuitBreakerName = String.format("SMB-%s:%d", address.getHostAddress(), port);
        this.circuitBreaker = new SimpleCircuitBreaker(circuitBreakerName, 3, 2, 30000L);

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Transport#getResponseTimeout()
     */
    @Override
    protected int getResponseTimeout(final Request req) {

         * the entire path.
         */
        dr.pathConsumed -= 1 + server.length() + 1 + share.length();

        if (referrals != null && System.currentTimeMillis() + 10000 > referrals.expiration) {
            referrals = null;
        }
        if (referrals == null) {
            referrals = new CacheEntry(0);
        }
        referrals.map.put(key, dr);
    }

        @Test
        @DisplayName("Should handle maximum buffer index")
        void testMaxBufferIndex() throws SMBProtocolDecodingException {
            // Given
            int bufferSize = 10000;
            byte[] buffer = new byte[bufferSize];
            int bufferIndex = bufferSize - 4;
            SMBUtil.writeInt2(4, buffer, bufferIndex);
            SMBUtil.writeInt2(0, buffer, bufferIndex + 2);

     */
    protected int splitSize = 10;

    /**
     * Maximum size of the thumbnail generation task queue.
     */
    protected int thumbnailTaskQueueSize = 10000;

    /**
     * Number of tasks to process in bulk operations.
     */
    protected int thumbnailTaskBulkSize = 100;

    /**
     * Timeout in milliseconds for thumbnail task queue operations.

            // Given
            ByteBuffer buffer = ByteBuffer.allocate(32);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(10000L);
            buffer.putLong(3000L);
            buffer.putLong(3000L);
            buffer.putInt(8);
            buffer.putInt(512);

            // When
            fileFsFullSizeInfo.decode(buffer.array(), 0, 32);

    private FileBasicInfo fileBasicInfo;

    // Use Unix timestamps (milliseconds since 1970) for test values
    private static final long TEST_CREATE_TIME = System.currentTimeMillis() - 10000;
    private static final long TEST_LAST_ACCESS_TIME = System.currentTimeMillis() - 8000;
    private static final long TEST_LAST_WRITE_TIME = System.currentTimeMillis() - 6000;

      int chosen = Hashing.consistentHash(h, shards);
      if (chosen != last) {
        map.incrementAndGet(shards);
        last = chosen;
      }
    }
  }

  private static final int ITERS = 10000;
  private static final int MAX_SHARDS = 500;

  public void testConsistentHash_outOfRange() {
    assertThrows(IllegalArgumentException.class, () -> Hashing.consistentHash(5L, 0));
  }