@GwtCompatible
final class UsingToStringOrdering extends Ordering<Object> implements Serializable {
  static final UsingToStringOrdering INSTANCE = new UsingToStringOrdering();

  @Override
  public int compare(Object left, Object right) {
    return left.toString().compareTo(right.toString());
  }

  // preserve singleton-ness, so equals() and hashCode() work correctly
  private Object readResolve() {
    return INSTANCE;
  }

  @Override

	public abstract fun tag (Ljava/lang/Class;)Ljava/lang/Object;
	public abstract fun tag (Ljava/lang/Class;Lkotlin/jvm/functions/Function0;)Ljava/lang/Object;
	public abstract fun tag (Lkotlin/reflect/KClass;)Ljava/lang/Object;
	public abstract fun tag (Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function0;)Ljava/lang/Object;
	public abstract fun timeout ()Lokio/Timeout;
}

  /**
   * Returns an {@link ElementOrder} that specifies the order of iteration for the elements of
   * {@link #edges()}, {@link #adjacentNodes(Object)}, {@link #predecessors(Object)}, {@link
   * #successors(Object)} and {@link #incidentEdges(Object)}.
   *
   * @since 29.0
   */
  @Override
  ElementOrder<N> incidentEdgeOrder();

  //
  // Element-level accessors
  //

  /**

  }

  @Override
  public List<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */

  private final Set<Feature<?>> conflicts;
  private final Object source;

  public ConflictingRequirementsException(
      String message, Set<Feature<?>> conflicts, Object source) {
    super(message);
    this.conflicts = conflicts;
    this.source = source;
  }

  public Set<Feature<?>> getConflicts() {
    return conflicts;
  }

  public Object getSource() {
    return source;
  }

  @Override

  @SuppressWarnings("unused")
  public void testTransformEntriesGenerics() {
    Map<Object, Object> map1 = ImmutableMap.<Object, Object>of(1, 2);
    Map<Object, Number> map2 = ImmutableMap.<Object, Number>of(1, 2);
    Map<Object, Integer> map3 = ImmutableMap.<Object, Integer>of(1, 2);
    Map<Number, Object> map4 = ImmutableMap.<Number, Object>of(1, 2);
    Map<Number, Number> map5 = ImmutableMap.<Number, Number>of(1, 2);

     */
    @Override
    public T getResponse() {
        return this.response;
    }

    /**
     * Create the response object for this request
     *
     * @param tc the CIFS context
     * @param req the request object
     * @return the response object
     */
    protected abstract T createResponse(CIFSContext tc, ServerMessageBlock2Request<T> req);

    /**
     *
     * {@inheritDoc}

        IoActions.writeTextFile(outputFile.asFile.get(), object : ErroringAction<BufferedWriter>() {
            @Throws(Exception::class)
            public
            override fun doExecute(bufferedWriter: BufferedWriter) {
                val packages = Implementation(excludes.get(), includes.get()).collectPackages(classpath.files.map(File::toPath))
                packages.dump(false, object : ErroringAction<String>() {

import com.google.common.collect.testing.features.MapFeature;
import java.util.List;
import java.util.Map.Entry;
import org.junit.Ignore;

/**
 * Testers for {@link ListMultimap#put(Object, Object)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")

// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public abstract class AbstractCollectionTester<E extends @Nullable Object>
    extends AbstractContainerTester<Collection<E>, E> {

  // TODO: replace this with an accessor.
  protected Collection<E> collection;

  @Override
  protected Collection<E> actualContents() {