import org.apache.maven.api.annotations.Experimental;

/**
 * @since 4.0.0
 */
@Experimental
@Consumer
public class VersionRangeResolverException extends MavenException {

    @Serial
    private static final long serialVersionUID = 4455478418692494141L;

    public VersionRangeResolverException(String message, Throwable cause) {
        super(message, cause);
    }

import org.apache.maven.api.annotations.Experimental;

/**
 * @since 4.0.0
 */
@Experimental
@Consumer
public class VersionResolverException extends MavenException {

    @Serial
    private static final long serialVersionUID = -2105433586719466573L;

    public VersionResolverException(String message, Throwable cause) {
        super(message, cause);
    }

   * @see FileChannel#map(MapMode, long, long)
   * @since 2.0
   */
  public static MappedByteBuffer map(File file) throws IOException {
    checkNotNull(file);
    return map(file, MapMode.READ_ONLY);
  }

  /**
   * Fully maps a file in to memory as per {@link
   * FileChannel#map(java.nio.channels.FileChannel.MapMode, long, long)} using the requested {@link
   * MapMode}.
   *

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close () throws CIFSException;


    /**
     * @return the tree is connected
     */
    boolean isConnected ();


    /**
     * @return server timezone offset
     * @throws CIFSException
     */
    long getServerTimeZoneOffset () throws CIFSException;


    /**

# | CHAR          | java.lang.String     | String        |
# | VARCHAR       | java.lang.String     | String        |
# | LONGVARCHAR   | java.lang.String     | String        |
# | NUMERIC       | java.math.BigDecimal | decimal?      |
# | DECIMAL       | java.math.BigDecimal | decimal?      |
# | TINYINT       | java.lang.Integer    | int?          |
# | SMALLINT      | java.lang.Integer    | int?          |

    }
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    synchronized (lock) {
      while (true) {
        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;
        } else {
          long now = System.nanoTime();
          NANOSECONDS.timedWait(lock, nanos);

  private final ImmutableList<Entry<E>> entries;
  private final long size;

  static <E> ImmutableMultiset<E> create(Collection<? extends Entry<? extends E>> entries) {
    @SuppressWarnings("unchecked")
    Entry<E>[] entriesArray = entries.toArray((Entry<E>[]) new Entry<?>[0]);
    Map<E, Integer> delegateMap = Maps.newHashMapWithExpectedSize(entriesArray.length);
    long size = 0;
    for (int i = 0; i < entriesArray.length; i++) {

        return isContinue;
    }

    protected void log(final LogHelper logHelper, final LogType key, final Object... objs) {
        if (logHelper != null) {
            logHelper.log(key, objs);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        log(logHelper, LogType.START_THREAD, crawlerContext);

  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    throwIf(closed);
    throwIf(READ_THROWS);
    return in.read(b, off, len);
  }

  @Override
  public long skip(long n) throws IOException {
    throwIf(closed);
    throwIf(SKIP_THROWS);
    return in.skip(n);
  }

  @Override
  public int available() throws IOException {
    throwIf(closed);

    assertThat(primitives)
        .containsExactly(
            boolean.class,
            byte.class,
            char.class,
            double.class,
            float.class,
            int.class,
            long.class,
            short.class,
            void.class);

    assertThrows(UnsupportedOperationException.class, () -> primitives.remove(boolean.class));
  }

  public void testAllWrapperTypes() {