import org.apache.maven.artifact.Artifact;
import org.apache.maven.model.Exclusion;

/**
 * Filter to exclude from a list of artifact patterns.
 */
public class ExclusionArtifactFilter implements ArtifactFilter {

    private final List<Exclusion> exclusions;
    private final List<Predicate<Artifact>> predicates;

    public ExclusionArtifactFilter(List<Exclusion> exclusions) {

import org.apache.maven.plugin.MojoExecutionException;

/**
 * MojoExecutionScope
 */
public class MojoExecutionScope extends org.apache.maven.impl.di.MojoExecutionScope
        implements Scope, MojoExecutionListener {

    public <T> void seed(Class<T> clazz, Provider<T> value) {
        getScopeState().seed(clazz, value::get);
    }

    @Override

     */
    public void setMonitorInterval(final int monitorInterval) {
        this.monitorInterval = monitorInterval;
    }

    /**
     * Inner class that implements TimeoutTarget for monitoring job execution.
     */
    static class MonitorTarget implements TimeoutTarget {

        /** The job log being monitored */
        private final JobLog jobLog;

        /**
         * Constructor for MonitorTarget.

        .createTestSuite();
  }

  /**
   * To avoid infinite recursion, test suites with these marker features won't have derived suites
   * created for them.
   */
  enum NoRecurse implements Feature<Void> {
    SUBMULTISET,
    DESCENDING;

    @Override
    public Set<Feature<? super Void>> getImpliedFeatures() {
      return emptySet();
    }
  }

 * method {@link #cleanUp} is a no-op. All other methods throw an {@link
 * UnsupportedOperationException}.
 *
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
public abstract class AbstractCache<K, V> implements Cache<K, V> {

  /** Constructor for use by subclasses. */
  protected AbstractCache() {}

  /**
   * @since 11.0
   */
  @Override

  abstract class CheckedRunnable implements Runnable {
    abstract void realRun() throws Throwable;

    @Override
    public final void run() {
      try {
        realRun();
      } catch (Throwable t) {
        threadUnexpectedException(t);
      }
    }
  }

  abstract class CheckedCallable<T> implements Callable<T> {
    abstract T realCall() throws Throwable;

        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @author mbechler
     *
     */
    private static final class ResourceFilterWrapper implements ResourceFilter {

        /**
         *
         */
        private final SmbFileFilter ff;

        /**
         * @param ff
         */

        assertEquals((byte) 0xCC, buffer[24]);
    }

    @Test
    @DisplayName("Test request implements RequestWithFileId interface correctly")
    void testRequestWithFileIdInterface() {
        // Verify the class implements RequestWithFileId
        assertTrue(request instanceof jcifs.internal.smb2.RequestWithFileId);

        // Test interface method

    return checkNotNull(multiset);
  }

  static class UnmodifiableMultiset<E extends @Nullable Object> extends ForwardingMultiset<E>
      implements Serializable {
    final Multiset<? extends E> delegate;

    UnmodifiableMultiset(Multiset<? extends E> delegate) {
      this.delegate = delegate;
    }

    @SuppressWarnings("unchecked")

                }
              },
              isParallel)
          .onClose(stream::close);
    }
    final class Splitr extends MapWithIndexSpliterator<Spliterator<T>, R, Splitr>
        implements Consumer<T> {
      @Nullable T holder;

      Splitr(Spliterator<T> splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(@ParametricNullness T t) {