* @param maxStr string representation of maximum protocol version
     */
    protected void initProtocolVersions(final String minStr, final String maxStr) {
        final DialectVersion min = minStr != null && !minStr.isEmpty() ? DialectVersion.valueOf(minStr) : null;
        final DialectVersion max = maxStr != null && !maxStr.isEmpty() ? DialectVersion.valueOf(maxStr) : null;
        initProtocolVersions(min, max);
    }

    }

    // Test concurrent execution of hook method
    @Test
    public void test_hook_concurrentExecution() throws Exception {
        final FwAssistantDirector assistantDirector = createMockAssistantDirector();
        final int threadCount = 10;
        final AtomicBoolean hasError = new AtomicBoolean(false);

        Thread[] threads = new Thread[threadCount];

        for (int i = 0; i < threadCount; i++) {

  RegularImmutableTable() {}

  abstract Cell<R, C, V> getCell(int iterationIndex);

  @Override
  final ImmutableSet<Cell<R, C, V>> createCellSet() {
    return isEmpty() ? ImmutableSet.of() : new CellSet();
  }

  @WeakOuter
  private final class CellSet extends IndexedImmutableSet<Cell<R, C, V>> {
    @Override
    public int size() {
      return RegularImmutableTable.this.size();
    }

  }

  final Set<Throwable> getOrInitSeenExceptions() {
    if (seenExceptions == null) {
      seenExceptions = newHashSet();
      addInitialException(seenExceptions);
    }
    return seenExceptions;
  }

  abstract void addInitialException(Set<Throwable> seen);

  final int decrementRemainingAndGet() {
    return --remaining;
  }

  final void clearSeenExceptions() {

package com.google.common.primitives;

import com.google.common.annotations.GwtCompatible;

/** A string to be parsed as a number and the radix to interpret it in. */
@GwtCompatible
final class ParseRequest {
  final String rawValue;
  final int radix;

  private ParseRequest(String rawValue, int radix) {
    this.rawValue = rawValue;
    this.radix = radix;
  }

  static ParseRequest fromString(String stringValue) {

     */
    @Test
    public void testGetAsObject() throws Exception {
        final NumberConverter converter = new NumberConverter("##0");
        assertThat(converter.getAsObject("100"), is((Object) Long.valueOf("100")));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetAsString() throws Exception {
        final NumberConverter converter = new NumberConverter("##0");

import org.apache.maven.artifact.handler.ArtifactHandler;

import static java.util.Objects.requireNonNull;

class TransformedArtifactHandler implements ArtifactHandler {

    private final String classifier;

    private final String extension;

    private final String packaging;

    TransformedArtifactHandler(String classifier, String extension, String packaging) {
        this.classifier = classifier;

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#renewCredentials(java.lang.String, java.lang.Throwable)
     */
    @Override
    public boolean renewCredentials(final String locationHint, final Throwable error) {
        return false;
    }

    /**
     * {@inheritDoc}
     *
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override

   *     Queue<Integer>} but not a {@code Queue<Object>}).
   * @since 8.0
   */
  public static final class Builder<B> {
    /*
     * TODO(kevinb): when the dust settles, see if we still need this or can
     * just default to DEFAULT_CAPACITY.
     */
    private static final int UNSET_EXPECTED_SIZE = -1;

    private final Comparator<B> comparator;
    private int expectedSize = UNSET_EXPECTED_SIZE;

      return justAfterNull.hashCode();
    }
  }

  public static final class NullsBeforeB extends NullsBefore {
    public static final NullsBeforeB INSTANCE = new NullsBeforeB();

    private NullsBeforeB() {
      super("b");
    }
  }

  public static final class NullsBeforeTwo extends NullsBefore {
    public static final NullsBeforeTwo INSTANCE = new NullsBeforeTwo();

    private NullsBeforeTwo() {