* @param value the value to be associated with the specified key
   * @return the value that was previously associated with the key, or {@code null} if there was no
   *     previous entry. (If the bimap contains null values, then {@code forcePut}, like {@code
   *     put}, returns {@code null} both if the key is absent and if it is present with a null
   *     value.)
   */
  @CanIgnoreReturnValue

        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {

    for (Method method : testMethods) {
      suite.addTest(new ByteSourceTester(factory, bytes, name, desc, method));
    }

    if (slice && bytes.length > 0) {
      // test a random slice() of the ByteSource
      Random random = new Random();
      byte[] expected = factory.getExpected(bytes);
      // if expected.length == 0, off has to be 0 but length doesn't matter--result will be empty

things, all because they WOULD not remember the simple rules
their friends had taught them:  such as, that a red-hot poker
will burn you if you hold it too long; and that if you cut your
finger VERY deeply with a knife, it usually bleeds; and she had
never forgotten that, if you drink much from a bottle marked
`poison,' it is almost certain to disagree with you, sooner or
later.

     *
     * @return {@code true} if the dependency management information should be retrieved, {@code false} otherwise.
     */
    boolean isResolveManagedVersions();

    /**
     * Enables/disables resolution of the dependency management information.
     *
     * @param resolveManagedVersions {@code true} if the dependency management information should be retrieved, {@code

    }

    Violation maybeViolation(final JApiCompatibility member) {
        if (!(member instanceof JApiClass)) {
            return null
        }

        if (!changed(member)) {
            return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {

        String lifecyclePhase = mojoExecution.getLifecyclePhase();

        if (lifecyclePhase != null) {
            PhaseId phaseId = PhaseId.of(lifecyclePhase);
            if (lastLifecyclePhase == null) {
                lastLifecyclePhase = phaseId.phase();
            } else if (!phaseId.phase().equals(lastLifecyclePhase)) {
                project.addLifecyclePhase(lastLifecyclePhase);

            }
        }
        return logFileItems;
    }

    /**
     * Checks if the given filename is a log file.
     *
     * @param name the filename to check
     * @return true if the filename ends with .log or .log.gz, false otherwise
     */
    public static boolean isLogFilename(final String name) {

        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was absent");
                }));
    expectAdded(e3());
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testMappedToNull() {

```
--ftp="tls-private-key=path/to/private.key" --ftp="tls-public-cert=path/to/public.crt"
```

> NOTE: if MinIO distributed setup is already configured to run under TLS, FTP will automatically use the relevant
> certs from the server certificate chain, this is mainly to add simplicity of setup. However if you wish to terminate
> TLS certificates via a different domain for your FTP servers you may choose the above command line options.