}

// MissedTasks returns the number of ILM expiry tasks that were missed since
// there were no available workers.
func (e *expiryStats) MissedTasks() int64 {
	return e.missedExpiryTasks.Load()
}

// MissedFreeVersTasks returns the number of free version collection tasks that
// were missed since there were no available workers.
func (e *expiryStats) MissedFreeVersTasks() int64 {

 * default} methods. Specifically, it forwards calls only for methods that existed <a
 * href="https://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html">before {@code default}
 * methods were introduced</a>. For newer methods, like {@code forEachRemaining}, it inherits their
 * default implementations. When those implementations invoke methods, they invoke methods on the
 * {@code ForwardingIterator}.
 *

        // Create a buffer large enough to hold the read bytes
        byte[] buffer = new byte[6];
        int bytesRead = packet.readTrailerWireFormat(bais, buffer, 0);

        // Verify that 6 bytes were read, which is the expected length.
        assertEquals(6, bytesRead);
    }

    @Test
    void readTrailerWireFormatShouldThrowIOExceptionOnUnexpectedEOF() throws IOException {

import java.util.ArrayList;
import java.util.List;

/**
 * The NormalizerChain class implements the Normalizer interface and allows chaining multiple normalizers together.
 * It applies each normalizer in the order they were added to the chain.
 *
 * <p>Usage example:</p>
 * <pre>
 * NormalizerChain chain = new NormalizerChain();
 * chain.add(new SomeNormalizer());
 * chain.add(new AnotherNormalizer());

      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *
   * @param lastGoodStreamId the last stream ID processed, or zero if no streams were processed.
   * @param errorCode reason for closing the connection.
   * @param debugData only valid for HTTP/2; opaque debug data to send.
   */

     *     indexes, and the values the corresponding quantile values. When iterating, entries in the
     *     map are ordered by quantile index in the same order they were passed to the {@code
     *     indexes} method.
     */
    public Map<Integer, Double> compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

    /**

 * default} methods. Specifically, it forwards calls only for methods that existed <a
 * href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentMap.html">before
 * {@code default} methods were introduced</a>. For newer methods, like {@code forEach}, it inherits
 * their default implementations. When those implementations invoke methods, they invoke methods on
 * the {@code ForwardingConcurrentMap}.
 *

import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.Configuration;

/**
 * Unit tests for {@link SmbComFindClose2}.
 * The class is intentionally tiny – the tests mainly verify that the
 * parameter word (the session identifier) is written in little‑endian form
 * and that the {@code toString} helper contains the expected values.
 *
 * <p>The tests also exercise edge cases such as negative (wrap‑around) session

     *            to some artifact's metadata.
     * @param request The model building request that holds further settings, must not be {@code null}.
     * @param problems The container used to collect problems that were encountered, must not be {@code null}.
     * @return The interpolated model, never {@code null}.
     */
    Model interpolateModel(Model model, File projectDir, ModelBuildingRequest request, ModelProblemCollector problems);

* 🚨 Avoid using `Optional[SomeType]`
* Instead ✨ **use `Union[SomeType, None]`** ✨.

Both are equivalent and underneath they are the same, but I would recommend `Union` instead of `Optional` because the word "**optional**" would seem to imply that the value is optional, and it actually means "it can be `None`", even if it's not optional and is still required.

I think `Union[SomeType, None]` is more explicit about what it means.