* @param minutes the minute of the hour (0-59)
         * @param day the day of the week (1=Sunday, 7=Saturday)
         * @return true if this rule applies, false otherwise
         */
        public boolean isTarget(final int hours, final int minutes, final int day) {
            if (!reverse) {

   * is not guaranteed to return zero when the dataset consists of the same value multiple times,
   * due to numerical errors. However, it is guaranteed never to return a negative result.
   *
   * <h3>Non-finite values</h3>
   *
   * <p>If the dataset contains any non-finite values ({@link Double#POSITIVE_INFINITY}, {@link

   *
   * <p>This is guaranteed to return zero if the dataset contains a single pair of finite values. It
   * is not guaranteed to return zero when the dataset consists of the same pair of values multiple
   * times, due to numerical errors.
   *
   * <h3>Non-finite values</h3>
   *
   * <p>If the dataset contains any non-finite values ({@link Double#POSITIVE_INFINITY}, {@link

  public void testSchedule() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

    Future<?> unused1 = testExecutor.schedule(DO_NOTHING, 10, MINUTES);
    mock.assertLastMethodCalled("scheduleRunnable", 10, MINUTES);

    Future<?> unused2 = testExecutor.schedule(callable(DO_NOTHING), 5, SECONDS);
    mock.assertLastMethodCalled("scheduleCallable", 5, SECONDS);
  }

    }

    // Test edge cases to understand the validation behavior
    public void test_edgeCaseBehavior() {
        String[] edgeCases = { "0 0 25 * * ?", // Invalid day of month
                "0 60 * * * ?", // Invalid minute
                "0 0 0 32 1 ?", // Invalid day
                "0 0 0 1 13 ?", // Invalid month
        };

        for (String cron : edgeCases) {
            boolean result = validator.determineValid(cron);

     * SetView}.
     */
    abstract int minSize();

    /**
     * Returns the {@link #minSize()} of {@code set} if it is a {@link SetView}, or the exact {@link
     * #size()} of {@code set} otherwise.
     */
    static int minSize(Set<?> set) {
      return set instanceof SetView ? ((SetView<?>) set).minSize() : set.size();
    }

    /**

labels.joblog_delete_all_cancel=Annuler
labels.dict_configuration=Liste des dictionnaires
labels.dict_list_title=Liste des dictionnaires
labels.dict_list_link=Dictionnaire
labels.dictionary_name=Nom
labels.dictionary_type=Type
labels.dict_synonym_configuration=Liste des synonymes
labels.dict_synonym_title=Liste des synonymes
labels.dict_synonym_list_link=Liste
labels.dict_synonym_link_create=Créer nouveau

 * The representation of a linear transformation between real numbers {@code x} and {@code y}.
 * Graphically, this is the specification of a straight line on a plane. The transformation can be
 * expressed as {@code y = m * x + c} for finite {@code m} and {@code c}, unless it is a vertical
 * transformation in which case {@code x} has a constant value for all {@code y}. In the
 * non-vertical case, {@code m} is the slope of the transformation (and a horizontal transformation

plugins {
  id("com.android.application")
  id("kotlin-android")
}

android {
  compileSdk = 36

  namespace = "okhttp.android.testapp"

  testBuildType = "release"

  defaultConfig {
    minSdk = 21
    targetSdk = 36
    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  }

  compileOptions {
    targetCompatibility(JavaVersion.VERSION_11)
    sourceCompatibility(JavaVersion.VERSION_11)

  }

  /**
   * Returns a {@link SetView} with a {@link SetView#minSize()} of {@code min} and a {@link
   * SetView#maxSize()} of {@code max}.
   */
  private static SetView<Integer> setSizeRange(int min, int max) {
    checkArgument(min >= 0 && max >= min);
    SetView<Integer> set = difference(setSize(max), setSize(max - min));
    checkState(set.minSize() == min && set.maxSize() == max);
    return set;
  }

  /**