assertEquals(2, crawlerContext.getRobotsTxtUrlSet().size());

        // Set new set
        Set<String> newSet = new HashSet<>();
        newSet.add("http://new.com/robots.txt");
        crawlerContext.setRobotsTxtUrlSet(newSet);
        assertSame(newSet, crawlerContext.getRobotsTxtUrlSet());
        assertEquals(1, crawlerContext.getRobotsTxtUrlSet().size());

        // Set null

        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertThat(cache.asMap().put(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertThat(cache.getUnchecked(entry.getKey())).isEqualTo(newValue);
        assertThat(cache.getUnchecked(newKey)).isEqualTo(entry.getValue());
        // don't let the new entry get GCed

     * newest entry exceeds the maximum weight all on its own.
     *
     * @param newest the most recently added entry
     */
    @GuardedBy("this")
    void evictEntries(ReferenceEntry<K, V> newest) {
      if (!map.evictsBySize()) {
        return;
      }

      drainRecencyQueue();

          StrongKeyStrongValueSegment<K, V> segment,
          StrongKeyStrongValueEntry<K, V> entry,
          @Nullable StrongKeyStrongValueEntry<K, V> newNext) {
        StrongKeyStrongValueEntry<K, V> newEntry =
            newEntry(segment, entry.key, entry.hash, newNext);
        newEntry.value = entry.value;
        return newEntry;
      }

      @Override
      public void setValue(

        assertTrue(keyManager.hasSessionKey(sessionId + ".v0"), "Archived key should exist");

        // New key should be different
        byte[] newKey = keyManager.getRawKey(sessionId);
        assertNotNull(newKey, "New key should exist");
        assertFalse(Arrays.equals(testKey, newKey), "New key should be different from old key");
    }

    @Test
    public void testMultipleKeyRotations() throws GeneralSecurityException {

        byte[] decrypted1 = context.decryptMessage(encrypted1);
        assertArrayEquals(plaintext1, decrypted1);

        // When - Rotate keys
        byte[] newKey = new byte[16];
        new SecureRandom().nextBytes(newKey);
        context.rotateKeys(newKey, newKey); // Use same key for test

        // Then - Can encrypt/decrypt with new keys
        byte[] plaintext2 = "After key rotation".getBytes();

        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertThat(cache.asMap().put(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertThat(cache.getUnchecked(entry.getKey())).isEqualTo(newValue);
        assertThat(cache.getUnchecked(newKey)).isEqualTo(entry.getValue());
        // don't let the new entry get GCed

// which are used to migrate log entries between old and new targets.
func CreateOrAdjustGlobalBuffer(currentTgt *Target, newTgt *Target) {
	logChLock.Lock()
	defer logChLock.Unlock()

	requiredCap := currentTgt.config.QueueSize + (currentTgt.config.BatchSize * int(currentTgt.maxWorkers))
	currentCap := 0
	name := newTgt.Name()

	currentBuff, ok := logChBuffers[name]
	if !ok {
		logChBuffers[name] = make(chan any, requiredCap)

	}
	return versions, buf, nil
}

// decodeVersions will decode a number of versions from a buffer
// and perform a callback for each version in order, newest first.
// Any non-nil error is returned.
func decodeVersions(buf []byte, versions int, fn func(idx int, hdr, meta []byte) error) (e error) {
	var tHdr, tMeta []byte // Zero copy bytes
	for i := 0; i < versions; i++ {

		currentTgt, ok := oldTargets[i].(*http.Target)
		if !ok {
			continue
		}
		var newTgt *http.Target

		for ii := range tgts {
			if currentTgt.Name() == tgts[ii].Name() {
				newTgt = tgts[ii]
				currentTgt.AssignMigrateTarget(newTgt)
				http.CreateOrAdjustGlobalBuffer(currentTgt, newTgt)
				break
			}
		}
	}

	for _, t := range tgts {
		err := t.Init(ctx)
		if err != nil {