// When
        byte[] decKey = Smb3KeyDerivation.deriveDecryptionKey(dialect, sessionKey, preauthIntegrity);

        // Then
        assertNotNull(decKey, "Decryption key should not be null");
        assertEquals(16, decKey.length, "Decryption key should be 16 bytes");
        assertFalse(Arrays.equals(sessionKey, decKey), "Decryption key should be different from session key");
    }

        }
    }

    /**
     * Applies delay based on the configured interval rules.
     * This method calculates the appropriate delay for the current time
     * and applies it by sleeping the current thread.
     */
    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    /**

        this.delay = delay;
        this.unit = checkNotNull(unit);
      }

      /**
       * @param delay the time from now to delay execution
       * @since 33.4.0 (but since 31.1 in the JRE flavor)
       */
      @IgnoreJRERequirement // Users will use this only if they're already using Duration
      public Schedule(Duration delay) {
        this(toNanosSaturated(delay), NANOSECONDS);
      }

        this.delay = delay;
        this.unit = checkNotNull(unit);
      }

      /**
       * @param delay the time from now to delay execution
       * @since 31.1 (but only since 33.4.0 in the Android flavor)
       */
      public Schedule(Duration delay) {
        this(toNanosSaturated(delay), NANOSECONDS);
      }
    }

    /**

        t.numThreads = 5;
        t.numIter = 10;
        t.delay = 250L;
        t.url = "smb://custom/path/file.txt";

        // Verify values are set
        assertEquals(5, t.numThreads, "numThreads should be configurable");
        assertEquals(10, t.numIter, "numIter should be configurable");
        assertEquals(250L, t.delay, "delay should be configurable");

                    // Check for potential overflow before multiplication
                    long delay = (retryDelayMs > Long.MAX_VALUE / multiplier) ? MAX_RETRY_DELAY
                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);
                    Thread.sleep(delay);
                }

                // Attempt to reset the connection
                connection.reset();

	lastObject := ri.Object

	retryAttempts := job.KeyRotate.Flags.Retry.Attempts
	if retryAttempts <= 0 {
		retryAttempts = batchKeyRotateJobDefaultRetries
	}
	delay := job.KeyRotate.Flags.Retry.Delay
	if delay <= 0 {
		delay = batchKeyRotateJobDefaultRetryDelay
	}

	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))

	selectObj := func(info FileInfo) (ok bool) {

      }

    public fun headersDelay(
      delay: Long,
      unit: TimeUnit,
    ): Builder =
      apply {
        headersDelayNanos = unit.toNanos(delay)
      }

    /**
     * Set the delayed time of the response body to [delay]. This applies to the response body
     * only; response headers are not affected.
     */
    public fun bodyDelay(
      delay: Long,
      unit: TimeUnit,
    ): Builder =

    }

    private void scheduleRecovery(ChannelInfo channel, FailoverState state) {
        state.incrementRetry();

        // For test purposes, execute recovery immediately without delay
        // In production, this might use the delay from getNextRetryTime()
        executor.submit(() -> attemptRecovery(channel, state));
    }

errors.failed_to_upload_stopwords_file = Impossibile caricare il file delle stopwords.
errors.failed_to_download_elevate_file = Impossibile scaricare il file delle parole elevate.
errors.failed_to_upload_elevate_file = Impossibile caricare il file delle parole elevate.
errors.failed_to_download_badword_file = Impossibile scaricare il file delle parole proibite.