calcMethod.setAccessible(true);

        byte[] input = "test data".getBytes();
        byte[] oldHash = new byte[64];

        byte[] newHash = (byte[]) calcMethod.invoke(transport, input, 0, input.length, oldHash);

        assertNotNull(newHash);
        assertEquals(64, newHash.length); // SHA-512 produces 64 bytes

   * Returns an output {@code Future} to use in place of the given {@code input}. The output {@code
   * Future} need not be {@linkplain Future#isDone done}, making {@code AsyncFunction} suitable for
   * asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@code Future}.
   */
  ListenableFuture<O> apply(@ParametricNullness I input) throws Exception;

    /**
     * Reads up to b.length bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *

    /**
     * Creates a {@link Reader} to read from a file with the specified encoding.
     *
     * @param is
     *            the input stream (must not be {@literal null})
     * @param encoding
     *            the encoding of the input stream (must not be {@literal null} or empty)
     * @return a {@link Reader} to read from the file
     */

        }
    }

    /**
     * Updates the digest with the specified data.
     *
     * @param input the input buffer containing data to digest
     * @param offset the offset in the buffer where data starts
     * @param len the length of data to digest
     */
    public void update(final byte[] input, final int offset, final int len) {
        if (LogStream.level >= 5) {

  public void testRepeat() {
    String input = "20";
    assertEquals("", Strings.repeat(input, 0));
    assertEquals("20", Strings.repeat(input, 1));
    assertEquals("2020", Strings.repeat(input, 2));
    assertEquals("202020", Strings.repeat(input, 3));

    assertEquals("", Strings.repeat("", 4));

    for (int i = 0; i < 100; ++i) {
      assertEquals(2 * i, Strings.repeat(input, i).length());
    }

    for (Map.Entry<K, V> entry : map.entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

  /**
   * Populates a map by reading an input stream, as part of deserialization. See {@link #writeMap}
   * for the data format.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void populateMap(

  }

  public void testGrowBuffer() { // need to grow past an initial 1024 byte buffer
    StringBuilder input = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    for (int i = 256; i < 1024; i++) {
      input.append((char) i);
      expected.append("[" + i + "]");
    }
    assertThat(SIMPLE_ESCAPER.escape(input.toString())).isEqualTo(expected.toString());
  }

  public void testSurrogatePairs() {

  }

  public void testGrowBuffer() { // need to grow past an initial 1024 byte buffer
    StringBuilder input = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    for (int i = 256; i < 1024; i++) {
      input.append((char) i);
      expected.append("[" + i + "]");
    }
    assertThat(SIMPLE_ESCAPER.escape(input.toString())).isEqualTo(expected.toString());
  }

  public void testSurrogatePairs() {

      new Function<@Nullable Integer, @Nullable Integer>() {
        @Override
        public @Nullable Integer apply(@Nullable Integer input) {
          return (input == null) ? null : input / 2;
        }
      };

  abstract static class ColumnTests extends MapTests {
    ColumnTests(
        boolean allowsNullValues,
        boolean supportsPut,