public void testPutAllNullValueSingle_unsupported() {
    multimap().putAll(k1(), newArrayList((V) null));
    expectUnchanged();
  }

  // In principle, it would be nice to apply these two tests to keys with existing values, too.

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  public void testPutAllNullValueNullLast_unsupported() {
    int size = getNumElements();

     * as milliseconds from Jan 1, 1970 which is the same as that which is returned by the
     * <code>createTime()</code>, <code>lastModified()</code>, <code>lastAccess()</code> methods.
     * <br>
     * This method does not apply to workgroups, servers, or shares.
     *
     * @see #setCreateTime
     * @see #setLastAccess
     * @see #setLastModified
     *
     * @param createTime

    }

    /**
     * Creates a Type-1 message with the specified parameters.
     *
     * @param tc
     *            context to use
     * @param flags
     *            The flags to apply to this message.
     * @param suppliedDomain
     *            The supplied authentication domain.
     * @param suppliedWorkstation
     *            The supplied workstation name.
     */

         * @param oneArgLambda the function to apply for credential resolution
         */
        public <CREDENTIAL extends LoginCredential> void resolve(final Class<CREDENTIAL> credentialType,
                final Function<CREDENTIAL, OptionalEntity<FessUser>> oneArgLambda) {
            resolver.resolve(credentialType, credential -> oneArgLambda.apply(credential));
        }
    }

    /**

    private final Interner<E> interner;

    InternerFunction(Interner<E> interner) {
      this.interner = interner;
    }

    @Override
    public E apply(E input) {
      return interner.intern(input);
    }

    @Override
    public int hashCode() {
      return interner.hashCode();
    }

    @Override

   * concurrently updating.
   */
  public void reset() {
    internalReset(0L);
  }

  /**
   * Equivalent in effect to {@link #sum} followed by {@link #reset}. This method may apply for
   * example during quiescent points between multithreaded computations. If there are updates
   * concurrent with this method, the returned value is not guaranteed to be the final

import org.elasticsearch.gradle.internal.info.BuildParams
import org.jetbrains.gradle.ext.JUnit

import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.StandardCopyOption

allprojects {
  apply plugin: 'idea'

  tasks.named('idea').configure {
    doFirst { throw new GradleException("Use of the 'idea' task has been deprecated. For details on importing into IntelliJ see CONTRIBUTING.md.") }
  }
}

            when(ace1.getApplyToText()).thenReturn("");
            when(ace2.getApplyToText()).thenReturn(null);

            assertEquals("", ace1.getApplyToText(), "Should handle empty apply text");
            assertNull(ace2.getApplyToText(), "Should handle null apply text");

            verify(ace1).getApplyToText();
            verify(ace2).getApplyToText();
        }

        @Test

    $MVN_CMD = "mvnd.cmd"
    break
  }
  default {
    $USE_MVND = $false
    $MVN_CMD = $script -replace '^mvnw','mvn'
    break
  }
}

# apply MVNW_REPOURL and calculate MAVEN_HOME
# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
if ($env:MVNW_REPOURL) {

    private final Interner<E> interner;

    InternerFunction(Interner<E> interner) {
      this.interner = interner;
    }

    @Override
    public E apply(E input) {
      return interner.intern(input);
    }

    @Override
    public int hashCode() {
      return interner.hashCode();
    }

    @Override