this.closeables = closeables;
  }

  /**
   * Returns a future that finishes when this step does. Calling {@code get()} on the returned
   * future returns {@code null} if the step is successful or throws the same exception that would
   * be thrown by calling {@code finishToFuture().get()} if this were the last step. Calling {@code
   * cancel()} on the returned future has no effect on the {@code ClosingFuture} pipeline.
   *

        // and a file that is READONLY, HIDDEN, and SYSTEM
        when(mockFile.getAttributes()).thenReturn(SmbFile.ATTR_READONLY | SmbFile.ATTR_HIDDEN | SmbFile.ATTR_SYSTEM);

        // When calling accept
        // Then it should be accepted because the READONLY attribute is present
        assertTrue(dosFileFilter.accept(mockFile));
    }

    /**

import jcifs.SmbResource;

/**
 * Tests for {@link DirFileEntryAdapterIterator}.
 *
 * This test class verifies the basic functionality of DirFileEntryAdapterIterator.
 * Due to the iterator's constructor calling advance() immediately, which requires
 * the adapt() method to be functional, we test the behavior using simple mock
 * scenarios that don't require complex filter setups.
 */
@ExtendWith(MockitoExtension.class)

        // Configure the mock to throw DcerpcException when wrap is called
        doThrow(new DcerpcException("Test wrap exception")).when(dcerpcSecurityProvider).wrap(mockNdrBuffer);

        // Assert that calling wrap throws DcerpcException
        assertThrows(DcerpcException.class, () -> dcerpcSecurityProvider.wrap(mockNdrBuffer));

        // Verify that the wrap method was called exactly once

   */
  @Nullable Range<C> rangeContaining(C value);

  /**
   * Returns {@code true} if there exists a non-empty range enclosed by both a member range in this
   * range set and the specified range. This is equivalent to calling {@code
   * subRangeSet(otherRange)} and testing whether the resulting range set is non-empty.
   *
   * @since 20.0
   */
  boolean intersects(Range<C> otherRange);

  /**

   *     can <i>usually</i> still preserve behavior by passing an explicit {@code null} cause. Note,
   *     however, that passing an explicit {@code null} cause prevents anyone from calling {@link
   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**

    public static final int CONNECTION_REFUSED = -1;
    /** Not listening on the called name */
    public static final int NOT_LISTENING_CALLED = 0x80;
    /** Not listening for the calling name */
    public static final int NOT_LISTENING_CALLING = 0x81;
    /** Called name not present */
    public static final int CALLED_NOT_PRESENT = 0x82;
    /** Insufficient resources to establish session */

    /**
     * Creates a path matcher for filtering files based on include and exclude patterns,
     * without using default exclusion patterns.
     * <p>
     * This is equivalent to calling {@link #createPathMatcher(Path, Collection, Collection, boolean)}
     * with {@code useDefaultExcludes = false}.
     *
     * @param baseDirectory the base directory for relativizing paths during matching

    this.closeables = closeables;
  }

  /**
   * Returns a future that finishes when this step does. Calling {@code get()} on the returned
   * future returns {@code null} if the step is successful or throws the same exception that would
   * be thrown by calling {@code finishToFuture().get()} if this were the last step. Calling {@code
   * cancel()} on the returned future has no effect on the {@code ClosingFuture} pipeline.
   *

  /**
   * Any interruption that happens as a result of calling interruptTask will arrive before this
   * method is called. Complete Futures here.
   */
  abstract void afterRanInterruptiblySuccess(@ParametricNullness T result);

  /**
   * Any interruption that happens as a result of calling interruptTask will arrive before this
   * method is called. Complete Futures here.
   */