}
		delete(dst, key)
	}
	legalHold := GetObjectLegalHoldMeta(metadata)
	if !legalHold.Status.Valid() || filterLegalHold {
		delKey(AmzObjectLockLegalHold)
	}

	ret := GetObjectRetentionMeta(metadata)
	if !ret.Mode.Valid() || filterRetention {
		delKey(AmzObjectLockMode)
		delKey(AmzObjectLockRetainUntilDate)
		return dst
	}
	return dst

		currKVS := ck.Clone()
		defKVS := DefaultKVS[subSys]
		for delKey := range strings.FieldsSeq(inputs[1]) {
			_, ok := currKVS.Lookup(delKey)
			if !ok {
				return Error[ErrConfigNotFound]("key %s doesn't exist", delKey)
			}
			defVal, isDef := defKVS.Lookup(delKey)
			if isDef {
				currKVS.Set(delKey, defVal)
			} else {
				currKVS.Delete(delKey)
			}
		}
		c[subSys][tgt] = currKVS
	} else {

        // 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);
      }

	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) {

    }

    /**
     * Test multiple delay calls
     */
    public void test_multipleDelayCalls() {
        final TestIntervalController controller = new TestIntervalController();

        controller.delay(IntervalController.PRE_PROCESSING);
        controller.delay(IntervalController.POST_PROCESSING);
        controller.delay(IntervalController.NO_URL_IN_QUEUE);
        controller.delay(IntervalController.WAIT_NEW_URL);

        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");

        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);
      }
    }

    /**

      delay(SMALL_DELAY_MS);
      return Boolean.TRUE;
    }
  }

  public class MediumRunnable extends CheckedRunnable {
    @Override
    protected void realRun() throws Throwable {
      delay(MEDIUM_DELAY_MS);
    }
  }

  public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
    @Override
    protected void realRun() throws InterruptedException {
      delay(MEDIUM_DELAY_MS);