constraints.DecimalMax.message  = {item} doit être plus petit que ${inclusive == true ? 'or equal to ' : ''}{value}.
constraints.DecimalMin.message  = {item} doit être plus grand que  ${inclusive == true ? 'or equal to ' : ''}{value}.
constraints.Digits.message      = {item} est une valeur numérique hors des limites (Il faut <{integer} chiffres>.<{fraction} chiffres>).
constraints.Future.message      = {item} doit être dans le futur.

        try {
            validateLocalRepository(request);
        } catch (IOException e) {
            return addExceptionToResult(result, e);
        }

        //
        // We enter the session scope right after the MavenSession creation and before any of the
        // AbstractLifecycleParticipant lookups
        // so that @SessionScoped components can be @Injected into AbstractLifecycleParticipants.
        //

  /**
   * Prevents the given methods from being run as part of the test suite.
   *
   * <p>Note: in principle this should never need to be used, but it might be useful if the
   * semantics of an implementation disagree in unforeseen ways with the semantics expected by a
   * test, or to keep dependent builds clean in spite of an erroneous test.
   */
  @CanIgnoreReturnValue

  // but not yet healthy are considered disrupted and can be evicted regardless
  // of whether the criteria in a PDB is met. This means perspective running
  // pods of a disrupted application might not get a chance to become healthy.
  // Healthy pods will be subject to the PDB for eviction.
  //
  // Additional policies may be added in the future.

   */
  @Override
  boolean containsAll(Collection<?> elements);

  /**
   * {@inheritDoc}
   *
   * <p><b>Note:</b> This method ignores how often any element might appear in {@code c}, and only
   * cares whether or not an element appears at all. If you wish to remove one occurrence in this
   * multiset for every occurrence in {@code c}, see {@link Multisets#removeOccurrences(Multiset,

  fun nextFrame(
    requireSettings: Boolean,
    handler: Handler,
  ): Boolean {
    try {
      source.require(9) // Frame header size.
    } catch (e: EOFException) {
      return false // This might be a normal socket close.
    }

    //  0                   1                   2                   3
    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

              if (entry.getLowerBound().compareTo(subRange.upperBound) >= 0) {
                return endOfData();
              } else if (entry.getUpperBound().compareTo(subRange.lowerBound) > 0) {
                // this might not be true e.g. at the start of the iteration
                return immutableEntry(entry.getKey().intersection(subRange), entry.getValue());
              }
            }
            return endOfData();
          }

          } catch (AccessControlException e) {
            // OK: the method is accessible to us anyway. The setAccessible call is only for
            // unusual execution environments where that might not be true.
          }
          builder.put(method.getName(), method);
        }
      }
      typeVariableMethods = builder.buildKeepingLast();
    }

      // but work beyond that must take at least one second
      assertTrue(afterBurst >= 1000);
    }
  }

  /**
   * This neat test shows that no matter what weights we use in our requests, if we push X amount of
   * permits in a cool state, where X = rate * timeToCoolDown, and we have specified a
   * timeToWarmUp() period, it will cost as the prescribed amount of time. E.g., calling

      // but work beyond that must take at least one second
      assertTrue(afterBurst >= 1000);
    }
  }

  /**
   * This neat test shows that no matter what weights we use in our requests, if we push X amount of
   * permits in a cool state, where X = rate * timeToCoolDown, and we have specified a
   * timeToWarmUp() period, it will cost as the prescribed amount of time. E.g., calling