}
            
            // Create new lease
            Smb2LeaseKey newKey = new Smb2LeaseKey();
            LeaseEntry newEntry = new LeaseEntry(newKey, path, requestedState);
            leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);
            
            return newKey;
        } finally {
            lock.writeLock().unlock();
        }
    }
    

                                for (Map.Entry<String, Object> deepEntry : deepMap.entrySet()) {
                                    String deepKey = nestedKey + "." + deepEntry.getKey();
                                    result = result.replace("${" + deepKey + "}", String.valueOf(deepEntry.getValue()));
                                }
                            }

/**
 * A generator of {@code TestSuite} instances for testing {@code CharSink} implementations.
 * Generates tests of all methods on a {@code CharSink} given various inputs written to it.
 *
 * @author Colin Decker
 */
@AndroidIncompatible // TODO(b/230620681): Make this available (even though we won't run it).
@NullUnmarked
public class CharSinkTester extends SourceSinkTester<CharSink, String, CharSinkFactory> {

      if (testAsCharSource) {
        suite.addTest(suiteForString(factory, entry.getValue(), name, entry.getKey()));
      } else {
        suite.addTest(
            suiteForBytes(factory, entry.getValue().getBytes(UTF_8), name, entry.getKey(), true));
      }
    }
    return suite;
  }

  static TestSuite suiteForString(

/**
 * A generator of {@code TestSuite} instances for testing {@code CharSink} implementations.
 * Generates tests of all methods on a {@code CharSink} given various inputs written to it.
 *
 * @author Colin Decker
 */
@AndroidIncompatible // TODO(b/230620681): Make this available (even though we won't run it).
@NullUnmarked
public class CharSinkTester extends SourceSinkTester<CharSink, String, CharSinkFactory> {

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

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArraySet;
import org.jspecify.annotations.Nullable;

/**
 * Registry of subscribers to a single event bus.
 *
 * @author Colin Decker
 */
final class SubscriberRegistry {

  /**
   * All registered subscribers, indexed by event type.
   *
   * <p>The {@link CopyOnWriteArraySet} values make it easy and relatively lightweight to get an

func (ssekms) ParseMetadata(metadata map[string]string) (keyID string, kmsKey []byte, sealedKey SealedKey, ctx kms.Context, err error) {
	// Extract all required values from object metadata
	b64IV, ok := metadata[MetaIV]
	if !ok {
		return keyID, kmsKey, sealedKey, ctx, errMissingInternalIV
	}
	algorithm, ok := metadata[MetaAlgorithm]
	if !ok {
		return keyID, kmsKey, sealedKey, ctx, errMissingInternalSealAlgorithm
	}

    for (ListIterator<Entry<K, V>> i = expected.listIterator(); i.hasNext(); ) {
      if (Helpers.equal(i.next().getKey(), newEntry.getKey())) {
        i.set(newEntry);
        return;
      }
    }

    throw new IllegalArgumentException(
        Platform.format("key %s not found in entries %s", newEntry.getKey(), expected));
  }

  /**

    assertEquals(c.getKey(), navigableMap.lastKey());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapExclusive() {
    assertFalse(navigableMap.headMap(a.getKey()).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapInclusive() {
    assertTrue(navigableMap.tailMap(a.getKey()).containsKey(a.getKey()));
  }

  public void testHeadMap() {