assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

  public void testTransformChangesAreReflectedInUnderlyingMap() {
    Map<String, Integer> underlying = new LinkedHashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    underlying.put("d", 4);

   * <p>Changes to the returned map will update the underlying table, and vice versa.
   *
   * @param columnKey key of column to search for in the table
   * @return the corresponding map from row keys to values
   */
  Map<R, V> column(@ParametricNullness C columnKey);

  /**
   * Returns a set of all row key / column key / value triplets. Changes to the returned set will

        // Assert
        // Verify that data was written to the underlying stream through CacheStream
        verify(initialOutputStream).write(testData);
        verify(initialOutputStream).flush();
        verify(initialOutputStream).close();
    }

    /**
     * Test that a RuntimeCIFSException is thrown when the handshake fails due to an underlying exception.
     * @throws IOException
     */
    @Test

    @Test
    @DisplayName("acquire after release reacquires underlying tree connection")
    void acquireAfterReleaseReacquires() {
        // After dropping to zero, acquire() should reacquire the underlying connection
        // Drop usage to zero
        handle.release();
        verify(treeConnection, times(1)).release();

        // Acquire from 0 -> 1 should acquire underlying

   * most once unless the underlying {@code get()} throws an exception. The supplier's serialized
   * form does not contain the cached value, which will be recalculated when {@code get()} is called
   * on the deserialized instance.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep

	}
	buf.Write(frag)
	return buf.String(), err
}

// WriteTo implements io.WriterTo.
// This may make multiple calls to the [Reader.Read] method of the underlying [Reader].
// If the underlying reader supports the [Reader.WriteTo] method,
// this calls the underlying [Reader.WriteTo] without buffering.
func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
	b.lastByte = -1
	b.lastRuneSize = -1

	if b.r < b.w {

   * the source will contain the concatenated data from the streams of the underlying sources.
   *
   * <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
   * close the open underlying stream.
   *
   * @param sources the sources to concatenate
   * @return a {@code CharSource} containing the concatenated data
   * @since 15.0

   * the source will contain the concatenated data from the streams of the underlying sources.
   *
   * <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
   * close the open underlying stream.
   *
   * @param sources the sources to concatenate
   * @return a {@code CharSource} containing the concatenated data
   * @since 15.0

    }

    /**
     * Invokes the underlying method represented by the {@link Method} object, with the specified object and parameters.
     *
     * @param <T>
     *            The return type of the method
     * @param method
     *            The method. Cannot be {@literal null}
     * @param target
     *            The object on which the underlying method is to be called. {@literal null} for {@literal static} methods

   * the source will contain the concatenated data from the streams of the underlying sources.
   *
   * <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
   * close the open underlying stream.
   *
   * @param sources the sources to concatenate
   * @return a {@code ByteSource} containing the concatenated data
   * @since 15.0