* then Lock B, while another thread acquires Lock B, and then Lock A:
 *
 * <pre>
 * Thread1: acquire(LockA) --X acquire(LockB)
 * Thread2: acquire(LockB) --X acquire(LockA)
 * </pre>
 *
 * <p>Neither thread will progress because each is waiting for the other. In more complex
 * applications, cycles can arise from interactions among more than 2 locks:
 *
 * <pre>
 * Thread1: acquire(LockA) --X acquire(LockB)

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testIsNull_serialization() {
    Predicate<String> pre = Predicates.isNull();
    Predicate<String> post = SerializableTester.reserializeAndAssert(pre);
    assertEquals(pre.apply("foo"), post.apply("foo"));
    assertEquals(pre.apply(null), post.apply(null));
  }

  public void testNotNull_apply() {

 * configured based on runtime conditions.
 * <p>
 * Example usage:
 * <pre>
 * public class Providers {
 *     {@literal @}Provides
 *     {@literal @}Singleton
 *     public static Configuration provideConfiguration() {
 *         return Configuration.load();
 *     }
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target(METHOD)
@Retention(RUNTIME)
@Documented

	dst := src[:0]
	var pre sparseEntry
	for _, cur := range src {
		if cur.Length == 0 {
			continue // Skip empty fragments
		}
		pre.Length = cur.Offset - pre.Offset
		if pre.Length > 0 {
			dst = append(dst, pre) // Only add non-empty fragments
		}
		pre.Offset = cur.endOffset()
	}
	pre.Length = size - pre.Offset // Possibly the only empty fragment
	return append(dst, pre)

 * <p>
 * Example usage:
 * <pre>
 * public class CustomPackagingProvider implements PackagingProvider {
 *     public Collection&lt;Packaging&gt; provides() {
 *         return Arrays.asList(
 *             packaging("docker-image"),
 *             packaging("flatpak")
 *         );
 *     }
 * }
 * </pre>
 *
 * @see org.apache.maven.api.Packaging

 * which implementation should be injected when multiple candidates exist.
 * The value represents a unique identifier for the dependency.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Inject
 * {@literal @}Named("mysql")
 * private Repository mysqlRepository;
 * </pre>
 *
 * @see Inject
 * @see Qualifier
 * @since 4.0.0
 */
@Qualifier
@Retention(RUNTIME)
@Documented
public @interface Named {
    /**

 * throughout the Maven build process.
 * <p>
 * Example usage:
 * <pre>
 * public class CustomLanguageProvider implements LanguageProvider {
 *     public Collection&lt;Language&gt; provides() {
 *         return Collections.singleton(language("kotlin"));
 *     }
 * }
 * </pre>
 *
 * @see org.apache.maven.api.Language
 * @see org.apache.maven.api.spi.ExtensibleEnumProvider
 * @since 4.0.0

import org.jspecify.annotations.Nullable;

/**
 * Tester for equals() and hashCode() methods of a class.
 *
 * <p>The simplest use case is:
 *
 * <pre>
 * new EqualsTester().addEqualityGroup(foo).testEquals();
 * </pre>
 *
 * <p>This tests {@code foo.equals(foo)}, {@code foo.equals(null)}, and a few other operations.
 *

* ⬆ [pre-commit.ci] pre-commit autoupdate. PR [#13634](https://github.com/fastapi/fastapi/pull/13634) by [@pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci).
* ⬆ [pre-commit.ci] pre-commit autoupdate. PR [#13619](https://github.com/fastapi/fastapi/pull/13619) by [@pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci).

    restart:
    while (true) {
      Waiter pred = null;
      Waiter curr = waitersField;
      if (curr == Waiter.TOMBSTONE) {
        return; // give up if someone is calling complete
      }
      Waiter succ;
      while (curr != null) {
        succ = curr.next;
        if (curr.thread != null) { // we aren't unlinking this node, update pred.
          pred = curr;