}

  private CharStreams() {}

  /**
   * Copies all characters between the {@link Readable} and {@link Appendable} objects. Does not
   * close or flush either object.
   *
   * @param from the object to read from
   * @param to the object to write to
   * @return the number of characters copied
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue

   */
  public static <A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f) {
    return new FunctionComposition<>(g, f);
  }

  private static final class FunctionComposition<
          A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      implements Function<A, C>, Serializable {

   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

  private static final class SupplierComposition<
          F extends @Nullable Object, T extends @Nullable Object>
      implements Supplier<T>, Serializable {

 * the License.
 */

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;

/**
 * Holder for extra methods of {@code Objects} only in web. Intended to be empty for regular
 * version.
 */
@GwtCompatible

 * the License.
 */

package com.google.common.cache;

import com.google.common.annotations.GwtCompatible;

/**
 * Abstract interface for objects that can concurrently add longs.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
interface LongAddable {
  void increment();

  void add(long x);

  long sum();

  }

  private static <E extends @Nullable Object> void assertCollectionsAreEquivalent(
      Collection<E> expected, Collection<E> actual) {
    assertIteratorsInOrder(expected.iterator(), actual.iterator());
  }

  private static <K extends @Nullable Object, V extends @Nullable Object>
      void assertMultimapRemainsUnmodified(Multimap<K, V> expected, List<Entry<K, V>> actual) {

   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

  private static final class SupplierComposition<
          F extends @Nullable Object, T extends @Nullable Object>
      implements Supplier<T>, Serializable {

        // Verify that dec_ndr_hyper was called exactly once
        verify(mockNdrBuffer, times(1)).dec_ndr_hyper();
        verifyNoMoreInteractions(mockNdrBuffer);

        // Verify that the NdrHyper object's value was updated correctly
        assertEquals(decodedValue, ndrHyper.value, "Decode should update the value correctly.");
    }

                && Objects.equals(classifier, that.classifier)
                && Objects.equals(version, that.version);
    }

    @Override
    public int hashCode() {
        return Objects.hash(groupId, artifactId, type, classifier, version);
    }

    @Override
    public String getBaseVersion() {
        if (baseVersion == null && version != null) {
            setBaseVersionInternal(version);
        }

    tester.addEqualityGroup(instance, createInstance(factory, equalArgs));
    for (int i = 0; i < params.size(); i++) {
      List<Object> newArgs = new ArrayList<>(args);
      Object newArg = argGenerators.get(i).generateFresh(params.get(i).getType());

      if (newArg == null || Objects.equals(args.get(i), newArg)) {
        if (params.get(i).getType().getRawType().isEnum()) {