* decide not to by returning -1L.
 *
 * Task Queues
 * -----------
 *
 * Tasks are bound to the [TaskQueue] they are scheduled in. Each queue is sequential and the tasks
 * within it never execute concurrently. It is an error to use a task in multiple queues.
 */
abstract class Task(
  val name: String,
  val cancelable: Boolean = true,
) {
  // Guarded by the TaskRunner.

   * 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

    }

    @Override
    public String getLocation() {
        return location;
    }

    /**
     * Gets the content of this source.
     *
     * @return The underlying character stream, never {@code null}.
     */
    public String getContent() {
        return content;
    }

    @Override
    public String toString() {
        return getLocation();
    }

    @Override

   * 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 org.gradle.api.tasks.UntrackedTask
import org.gradle.util.internal.VersionNumber
import org.jetbrains.annotations.VisibleForTesting

/**
 * Fetch the latest Kotlin versions and write a properties file.
 * Never up-to-date, non-cacheable.
 */
@UntrackedTask(because = "Not worth tracking")
abstract class UpdateKotlinVersions : AbstractVersionsUpdateTask() {

    @get:Internal
    abstract val minimumSupported: Property<String>

        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

     * in the former case, this method can never return zero, while in the latter, it will return
     * zero if all occurrences of the element were since removed from the multiset.
     *
     * @return the count of the element; never negative
     */
    int getCount();

    /**
     * {@inheritDoc}
     *

    assertFalse(
        "Lists of different sizes should not be equal.",
        getList().equals(new ArrayList<E>(moreElements)));
  }

  public void testEquals_set() {
    assertFalse("A List should never equal a Set.", getList().equals(MinimalSet.from(getList())));
  }

      assertFalse(
          "removeIf(Predicate) should return false or throw UnsupportedOperationException",
          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)