void testInvalidFiletime() throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write the special "never" FILETIME value
        writeLittleEndianInt(dos, 0xffffffff);
        writeLittleEndianInt(dos, 0x7fffffff);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

import org.mockito.Mockito;
import org.slf4j.Logger;

import static org.mockito.ArgumentMatchers.matches;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;

@Deprecated
class ExecutionEventLoggerTest {

    private Logger logger;
    private ExecutionEventLogger executionEventLogger;

  private val readCompleteLatch = CountDownLatch(1)

  // The lists are held as a large array of UTF-8 bytes. This is to avoid allocating lots of strings
  // that will likely never be used. Each rule is separated by '\n'. Please see the
  // PublicSuffixListGenerator class for how these lists are generated.
  // Guarded by this.
  override lateinit var bytes: ByteString

   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *
   * <p>We sometimes also use {@code sneakyThrow} for testing how our code responds to
   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can
   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue

import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.io.InterruptedIOException;

   *
   * <p>The returned object is serializable if {@code function} is serializable.
   *
   * @param function the function to be used for loading values; must never return {@code null}
   * @return a cache loader that loads values by passing each key to {@code function}
   */
  public static <K, V> CacheLoader<K, V> from(Function<K, V> function) {

     *
     * Both scenarios are bad: The output Future might never complete, or, if it does complete, it
     * might not run some of its listeners. The likely result is that the app will hang. (And of
     * course stack overflows are bad news in general. For example, we may have overflowed in the
     * middle of defining a class. If so, that class will never be loadable in this process.) The

   * <p>Note in particular that an equivalence wrapper is never equal to the object it wraps.
   *
   * {@snippet :
   * equiv.wrap(obj).equals(obj) // always false
   * }
   *
   * @since 10.0
   */
  public static final class Wrapper<T extends @Nullable Object> implements Serializable {
    /*
     * Equivalence's type argument is always non-nullable: Equivalence<Number>, never

        for (int i = 1; i < instants.length; i++) {
            assertTrue(
                    instants[i].compareTo(instants[i - 1]) >= 0,
                    "Time should never go backwards even with rapid successive calls");
        }
    }

    @Test
    @DisplayName("MonotonicClock should maintain reasonable alignment with system time")
    void testSystemTimeAlignment() {

import org.gradle.util.internal.VersionNumber
import org.jetbrains.annotations.VisibleForTesting
import org.jsoup.Jsoup

/**
 * Fetch the latest AGP versions and write a properties file.
 * Never up-to-date, non-cacheable.
 *
 * AGP major versions are aligned with Gradle major versions.
 * IOW, AGP X.y officially only supports Gradle X.z.
 *
 * This task leverages that alignment to automatically select which