import java.util.Collection;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.Nullable;

/**
 * A {@link BlockingQueue} which forwards all its method calls to another {@link BlockingQueue}.
 * Subclasses should override one or more methods to modify the behavior of the backing collection
 * as desired per the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator
 * pattern</a>.
 *

        final int start = dstIndex;

        SMBUtil.writeInt2(mapInformationLevel(this.informationLevel), dst, dstIndex);
        dstIndex += 2;

        /*
         * windows98 has what appears to be another 4 0's followed by the share
         * name as a zero terminated ascii string "\TMP" + '\0'
         *
         * As is this works, but it deviates from the spec section 4.1.6.6 but

import com.google.common.collect.ImmutableMap;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.concurrent.ExecutionException;

/**
 * A cache which forwards all its method calls to another cache. Subclasses should override one or
 * more methods to modify the behavior of the backing cache as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

 * try-with-resources. To get the equivalent of that, you must wrap the above code in <i>another</i>
 * try block in order to catch any exception that may be thrown (including from the call to {@code
 * close()}).
 *
 * <p>This pattern ensures the following:
 *
 * <ul>
 *   <li>Each {@code Closeable} resource that is successfully registered will be closed later.

            return false;
        if (getClass() != obj.getClass())
            return false;
        RequestData other = (RequestData) obj;
        return method == other.method && Objects.equals(url, other.url)
                && Float.floatToIntBits(weight) == Float.floatToIntBits(other.weight);
    }

    /**
     * Returns a string representation of this object.
     * @return A string representation.

// polluted with single-access data. The ZFS read cache (ARC) is scan-resistant
// so there is no risk of polluting the entire cache with data accessed once.
// Another goal of DirectIO is to minimize the mutation of data by the kernel
// before issuing IO to underlying devices. ZFS users often enable features like
// compression and checksumming which currently necessitates mutating data in

    return new EquivalenceTester<>(equivalence);
  }

  /**
   * Adds a group of objects that are supposed to be equivalent to each other and not equivalent to
   * objects in any other equivalence group added to this tester.
   */
  @CanIgnoreReturnValue
  public EquivalenceTester<T> addEquivalenceGroup(T first, T... rest) {
    addEquivalenceGroup(Lists.asList(first, rest));

    return new EquivalenceTester<>(equivalence);
  }

  /**
   * Adds a group of objects that are supposed to be equivalent to each other and not equivalent to
   * objects in any other equivalence group added to this tester.
   */
  @CanIgnoreReturnValue
  public EquivalenceTester<T> addEquivalenceGroup(T first, T... rest) {
    addEquivalenceGroup(Lists.asList(first, rest));

   *
   * @throws NullPointerException if {@code input} is null and this predicate does not accept null
   *     arguments
   */
  boolean apply(@ParametricNullness T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Predicate} instances in this library have implemented this method to

import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Verifies the version of a dependency listed in a parent's
 * dependencyManagement section is chosen over another version of the same
 * dependency, listed transitively.
 *
 */
@Deprecated
@SuppressWarnings("checkstyle:UnusedLocalVariable")
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {