assertThat(readFileOrNull(getCleanFile("a", 1))).isEqualTo(afterRemoveFileContents)

    // After the edit is completed, its entry is still gone.
    a.setString(1, "a1")
    a.commit()
    assertAbsent("a")
    assertThat(cache.size()).isEqualTo(0)
  }

  @Test
  fun evictAll() {
    set("a", "a", "a")
    set("b", "b", "b")

### Other (Cleanup or Flake)

- NONE ([#130010](https://github.com/kubernetes/kubernetes/pull/130010), [@tallclair](https://github.com/tallclair)) [SIG Node]

## Dependencies

### Added
_Nothing has changed._

### Changed

    assertLockHeld()

    // If this connection is not accepting new exchanges, we're done.
    if (calls.size >= allocationLimit || noNewExchanges) return false

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host ==
      this

    maxIdleConnections: Int = 5,
    keepAliveDuration: Long = 5,
    timeUnit: TimeUnit = TimeUnit.MINUTES,
    taskRunner: TaskRunner = TaskRunner.INSTANCE,
    connectionListener: ConnectionListener = ConnectionListener.NONE,
  ) : this(
    RealConnectionPool(
      taskRunner = taskRunner,
      maxIdleConnections = maxIdleConnections,
      keepAliveDuration = keepAliveDuration,
      timeUnit = timeUnit,

        assertFalse(cos.done);
        assertTrue(cos.isInMemory());
        cos.close();
        assertFalse(cos.done);
    }

    @Test
    public void inFile() throws IOException {
        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
        assertFalse(cos.done);
        assertFalse(cos.isInMemory());

    Object one = new Object();
    assertThat(map.put(one, one)).isNull();
    assertThat(map.get(one)).isSameInstanceAs(one);
    assertThat(map.containsKey(one)).isTrue();
    assertThat(map.containsValue(one)).isTrue();
    Object two = new Object();
    assertThat(map.replace(one, two)).isSameInstanceAs(one);
    assertThat(map.containsKey(one)).isTrue();

    return new TrackedRunnable() {
      private volatile boolean done = false;

      @Override
      public boolean isDone() {
        return done;
      }

      @Override
      public void run() {
        try {
          delay(timeoutMillis);
          done = true;
        } catch (InterruptedException ok) {
        }
      }
    };
  }

  operator fun plus(other: EventListener): EventListener {
    val left =
      when {
        this === NONE -> return other
        this is AggregateEventListener -> this.eventListeners
        else -> arrayOf(this)
      }
    val right =
      when {
        other === NONE -> return this
        other is AggregateEventListener -> other.eventListeners
        else -> arrayOf(other)
      }

   */
  public long get(K key) {
    return map.getOrDefault(key, 0L);
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue
  public long incrementAndGet(K key) {
    return addAndGet(key, 1);
  }

  /**
   * Decrements by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue

     */
    @Deprecated
    public String decryptoText(final String text) {
        return decryptText(text);
    }

    /**
     * Polls an encryption cipher from the queue, creating a new one if none are available.
     *
     * @return an encryption cipher
     */
    protected Cipher pollEncryptoCipher() {
        Cipher cipher = encryptoQueue.poll();
        if (cipher == null) {
            try {