void testToString() {
        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        String result = trans2SetFileInfo.toString();

        assertNotNull(result);
        assertTrue(result.contains("Trans2SetFileInformation"));
        assertTrue(result.contains("fid=" + TEST_FID));
    }

    @Test
    @DisplayName("Test with FileBasicInfo")
    void testWithFileBasicInfo() {

    return ContiguousSet.closedOpen(0, 30);
  }

  private static <E> Set<Set<E>> toHashSets(Set<Set<E>> powerSet) {
    Set<Set<E>> result = new HashSet<>();
    for (Set<E> subset : powerSet) {
      result.add(new HashSet<E>(subset));
    }
    return result;
  }

  private static Object objectWithHashCode(int hashCode) {
    return new Object() {
      @Override
      public int hashCode() {

	return int(sum64 % uint64(cardinality))
}

// hashOrder - hashes input key to return consistent
// hashed integer slice. Returned integer order is salted
// with an input key. This results in consistent order.
// NOTE: collisions are fine, we are not looking for uniqueness
// in the slices returned.
func hashOrder(key string, cardinality int) []int {
	if cardinality <= 0 {

        .setBody(fileToBytes(file))
        .addHeader("content-type: " + contentType(path));
  }

  private Buffer fileToBytes(File file) throws IOException {
    Buffer result = new Buffer();
    result.writeAll(Okio.source(file));
    return result;
  }

  private String contentType(String path) {
    if (path.endsWith(".png")) return "image/png";
    if (path.endsWith(".jpg")) return "image/jpeg";

   * ImmutableMultimap} specified in the {@code ImmutableMultimap} class.
   */
  @Override
  public ImmutableSetMultimap<V, K> inverse() {
    ImmutableSetMultimap<V, K> result = inverse;
    return (result == null) ? (inverse = invert()) : result;
  }

  private ImmutableSetMultimap<V, K> invert() {
    Builder<V, K> builder = builder();
    for (Entry<K, V> entry : entries()) {

    public boolean isDeleted() {
        return isUpdated() && newInput.length() == 0;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        final int result = 1;
        return prime * result + input.hashCode();
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }

                counter[0]--;
              }
            };
          }
        };
    Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
    String result = CharStreams.toString(joinedReader);
    assertEquals(testString.length() * 3, result.length());
  }

  public void testReady() throws Exception {
    CharSource source = newCharSource("a");
    Iterable<? extends CharSource> list = ImmutableList.of(source, source);

    @Override
    public BiMap<Country, String> create(Object... entries) {
      BiMap<Country, String> result = EnumHashBiMap.create(Country.class);
      for (Object o : entries) {
        Entry<Country, String> entry = (Entry<Country, String>) o;
        result.put(entry.getKey(), entry.getValue());
      }
      return result;
    }

    @Override
    public SampleElements<Entry<Country, String>> samples() {

 *
 * <p>Much like {@link java.util.concurrent.Callable}, but returning a {@link ListenableFuture}
 * result.
 *
 * @since 20.0
 */
@FunctionalInterface
@GwtCompatible
public interface AsyncCallable<V extends @Nullable Object> {
  /**
   * Computes a result {@code Future}. The output {@code Future} need not be {@linkplain

      flags: Int,
      padding: Int,
    ): Int {
      var result = length
      if (flags and FLAG_PADDED != 0) result-- // Account for reading the padding length.
      if (padding > result) {
        throw IOException("PROTOCOL_ERROR padding $padding > remaining length $result")
      }
      result -= padding
      return result
    }
  }