public
abstract class TreeTraverser<T> {
  /** Constructor for use by subclasses. */
  public TreeTraverser() {}

  /**
   * Returns a tree traverser that uses the given function to navigate from a node to its children.
   * This is useful if the function instance already exists, or so that you can supply a lambda
   * expressions. If those circumstances don't apply, you probably don't need to use this; subclass

            return true;
        if (obj == null || getClass() != obj.getClass())
            return false;
        NetworkInterfaceInfo that = (NetworkInterfaceInfo) obj;
        return interfaceIndex == that.interfaceIndex && address != null ? address.equals(that.address) : that.address == null;
    }

    @Override
    public int hashCode() {
        int result = interfaceIndex;

 * @author Charles Fry
 */
@NullUnmarked
public final class TestingWeighers {

  /** Returns a {@link Weigher} that returns the given {@code constant} for every request. */
  static Weigher<Object, Object> constantWeigher(int constant) {
    return new ConstantWeigher(constant);
  }

  /** Returns a {@link Weigher} that uses the integer key as the weight. */
  static Weigher<Integer, Object> intKeyWeigher() {
    return new IntKeyWeigher();

But remember that when you import `Query`, `Path`, `Cookie` and others from `fastapi`, those are actually functions that return special classes.

///

/// info

To declare cookies, you need to use `Cookie`, because otherwise the parameters would be interpreted as query parameters.

///

/// info

import org.gradle.api.tasks.TaskAction;

import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;

/**
 * A Java class to verify that all .adoc files and their anchors listed in a JSON file exist
 * within a specified directory.
 */
@CacheableTask
public abstract class FindMissingDocumentationFiles extends DefaultTask {

    // Later attempts to set the future should return false.
    assertFalse(future.set(23));
    assertFalse(future.setException(new Exception("bar")));
    assertFalse(future.setFuture(SettableFuture.create()));
    // Check that the future has been set properly.
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
    assertEquals(42, (int) future.get());
  }

  public void testSetException() throws Exception {

/**
 * Funnels for common types. All implementations are serializable.
 *
 * @author Dimitris Andreou
 * @since 11.0
 */
@Beta
public final class Funnels {
  private Funnels() {}

  /** Returns a funnel that extracts the bytes from a {@code byte} array. */
  public static Funnel<byte[]> byteArrayFunnel() {
    return ByteArrayFunnel.INSTANCE;
  }

  private enum ByteArrayFunnel implements Funnel<byte[]> {
    INSTANCE;

   * implementing {@code stopping}. Note, however, that {@code stopping} does not run at exactly the
   * same times as {@code triggerShutdown}.
   */
  protected void triggerShutdown() {}

  /**
   * Returns the {@link Executor} that will be used to run this service. Subclasses may override

    }
  }

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testCompare() {
    for (double x : VALUES) {
      for (double y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage("%s, %s", x, y)
            .that(Doubles.compare(x, y))
            .isEqualTo(Double.compare(x, y));

/**
 * Represents a toolchain in the Maven build system.
 *
 * <p>A toolchain is a set of tools that can be used to build a project.
 * This interface allows users to define and configure various toolchains
 * that can be utilized by Maven during the build process. Toolchains can
 * include compilers, interpreters, and other tools that are necessary
 * for building a project in a specific environment.</p>
 *