import org.eclipse.aether.resolution.ArtifactResult;
import org.eclipse.aether.transfer.ArtifactNotFoundException;

/**
 */
@Named("classpath")
@Singleton
@Deprecated
public class ClasspathArtifactResolver implements ArtifactResolver {

    @Override
    public List<ArtifactResult> resolveArtifacts(
            RepositorySystemSession session, Collection<? extends ArtifactRequest> requests)

 * @param <V> Value parameter type
 * @since 20.0
 */
@Beta
public abstract class AbstractValueGraph<N, V> extends AbstractBaseGraph<N>
    implements ValueGraph<N, V> {
  /** Constructor for use by subclasses. */
  public AbstractValueGraph() {}

  @Override
  public Graph<N> asGraph() {
    return new AbstractGraph<N>() {
      @Override
      public Set<N> nodes() {
        return AbstractValueGraph.this.nodes();
      }

     */
    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.

        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

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

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

        /**
         *
         */
        private final SmbFileFilter ff;

        /**
         * @param ff
         */

        .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();
    }
  }

        assertNotNull(ignored);
        assertEquals(testRequest, ignored);
    }

    /**
     * Test implementation of Request interface
     */
    private static class TestRequest implements Request<TestResponse> {
        private TestResponse response;
        private boolean ignoreDisconnect = false;
        private int tid = 0;
        private SMBSigningDigest digest;
        private long mid = 0;

  }

  // TODO(cpovirk): Just use addSuppressed+getSuppressed now that we can rely on it.
  /** Suppressor that records suppressions. */
  private static class TestSuppressor implements Closer.Suppressor {

    private final List<Suppression> suppressions = new ArrayList<>();

    @Override
    public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {

/**
 * Tests {@link SequentialExecutor}.
 *
 * @author JJ Furman
 */
@NullUnmarked
public class SequentialExecutorTest extends TestCase {

  private static class FakeExecutor implements Executor {
    final Queue<Runnable> tasks = new ArrayDeque<>();

    @Override
    public void execute(Runnable command) {
      tasks.add(command);
    }

    boolean hasNext() {

import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;
import jcifs.util.Strings;

/**
 * File notification information
 *
 *
 * @author mbechler
 *
 */
public class FileNotifyInformationImpl implements FileNotifyInformation, Decodable {

    int nextEntryOffset;
    int action;
    int fileNameLength;
    String fileName;

    /**
     * Default constructor for decoding.
     */